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

visidata/movement.py

@@ -6,6 +6,7 @@ from visidata import vd, VisiData, BaseSheet, Sheet, Column, Progress, ALT, asyn
 
 def rotateRange(n, idx, reverse=False):
     'Wraps an iter starting from idx. Yields indices from idx to n and then 0 to idx.'
+    if n == 0: return []
     if reverse:
         rng = range(idx-1, -1, -1)
         rng2 = range(n-1, idx-1, -1)
@@ -96,47 +97,35 @@ def nextColRegex(sheet, colregex):
 def visibleWidth(self):
     'Width of column as is displayed in terminal'
     vcolidx = self.sheet.visibleCols.index(self)
+    if vcolidx not in self.sheet._visibleColLayout:
+        self.sheet.calcSingleColLayout(vcolidx)
     return self.sheet._visibleColLayout[vcolidx][1]
 
 
-Sheet.addCommand(None, 'go-left',  'cursorRight(-1)', 'go left'),
-Sheet.addCommand(None, 'go-down',  'cursorDown(+1)', 'go down'),
-Sheet.addCommand(None, 'go-up',    'cursorDown(-1)', 'go up'),
-Sheet.addCommand(None, 'go-right', 'cursorRight(+1)', 'go right'),
-Sheet.addCommand(None, 'go-pagedown', 'cursorDown(nScreenRows-1); sheet.topRowIndex = bottomRowIndex', 'scroll one page forward'),
-Sheet.addCommand(None, 'go-pageup', 'cursorDown(-nScreenRows+1); sheet.bottomRowIndex = topRowIndex', 'scroll one page backward'),
+Sheet.addCommand(None, 'go-left',  'cursorRight(-1)', 'go left')
+Sheet.addCommand(None, 'go-down',  'cursorDown(+1)', 'go down')
+Sheet.addCommand(None, 'go-up',    'cursorDown(-1)', 'go up')
+Sheet.addCommand(None, 'go-right', 'cursorRight(+1)', 'go right')
+Sheet.addCommand(None, 'go-pagedown', 'cursorDown(nScreenRows-1); sheet.topRowIndex = bottomRowIndex', 'scroll one page forward')
+Sheet.addCommand(None, 'go-pageup', 'cursorDown(-nScreenRows+1); sheet.bottomRowIndex = topRowIndex', 'scroll one page backward')
 
-Sheet.addCommand(None, 'go-leftmost', 'sheet.cursorVisibleColIndex = sheet.leftVisibleColIndex = 0', 'go all the way to the left of sheet'),
-Sheet.addCommand(None, 'go-top', 'sheet.cursorRowIndex = sheet.topRowIndex = 0', 'go all the way to the top of sheet'),
-Sheet.addCommand(None, 'go-bottom', 'sheet.cursorRowIndex = len(rows); sheet.topRowIndex = cursorRowIndex-nScreenRows', 'go all the way to the bottom of sheet'),
-Sheet.addCommand(None, 'go-rightmost', 'sheet.leftVisibleColIndex = len(visibleCols)-1; pageLeft(); sheet.cursorVisibleColIndex = len(visibleCols)-1', 'go all the way to the right of sheet'),
+Sheet.addCommand(None, 'go-leftmost', 'sheet.cursorVisibleColIndex = sheet.leftVisibleColIndex = 0', 'go all the way to the left of sheet')
+Sheet.addCommand(None, 'go-top', 'sheet.cursorRowIndex = sheet.topRowIndex = 0', 'go all the way to the top of sheet')
+Sheet.addCommand(None, 'go-bottom', 'sheet.cursorRowIndex = len(rows); sheet.topRowIndex = cursorRowIndex-nScreenRows', 'go all the way to the bottom of sheet')
+Sheet.addCommand(None, 'go-rightmost', 'sheet.leftVisibleColIndex = len(visibleCols)-1; pageLeft(); sheet.cursorVisibleColIndex = len(visibleCols)-1', 'go all the way to the right of sheet')
 
-@Sheet.command('BUTTON1_PRESSED', 'go-mouse', 'set cursor to row and column where mouse was clicked')
-def go_mouse(sheet):
-    ridx = sheet.visibleRowAtY(sheet.mouseY)
-    if ridx is not None:
-        sheet.cursorRowIndex = ridx
-    cidx = sheet.visibleColAtX(sheet.mouseX)
-    if cidx is not None:
-        sheet.cursorVisibleColIndex = cidx
-
-Sheet.addCommand(None, 'scroll-mouse', 'sheet.topRowIndex=cursorRowIndex-mouseY+1', 'scroll to mouse cursor location'),
-
-Sheet.addCommand('ScrollwheelUp', 'scroll-up', 'cursorDown(options.scroll_incr); sheet.topRowIndex += options.scroll_incr', 'scroll one row up'),
-Sheet.addCommand('ScrollwheelDown', 'scroll-down', 'cursorDown(-options.scroll_incr); sheet.topRowIndex -= options.scroll_incr', 'scroll one row down'),
-
-Sheet.addCommand('c', 'go-col-regex', 'sheet.cursorVisibleColIndex=nextColRegex(input("column name regex: ", type="regex-col", defaultLast=True))', 'go to next column with name matching regex')
+Sheet.addCommand('c', 'go-col-regex', 'sheet.cursorVisibleColIndex=nextColRegex(inputRegex("column name regex: ", type="regex-col", defaultLast=True))', 'go to next column with name matching regex')
 Sheet.addCommand('zc', 'go-col-number', 'sheet.cursorVisibleColIndex = int(input("move to column number: "))', 'go to given column number (0-based)')
 Sheet.addCommand('zr', 'go-row-number', 'sheet.cursorRowIndex = int(input("move to row number: "))', 'go to the given row number (0-based)')
 
 
-Sheet.addCommand('<', 'go-prev-value', 'moveToNextRow(lambda row,sheet=sheet,col=cursorCol,val=cursorTypedValue: col.getTypedValue(row) != val, reverse=True, msg="no different value up this column")', 'go up current column to next value'),
-Sheet.addCommand('>', 'go-next-value', 'moveToNextRow(lambda row,sheet=sheet,col=cursorCol,val=cursorTypedValue: col.getTypedValue(row) != val, msg="no different value down this column")', 'go down current column to next value'),
-Sheet.addCommand('{', 'go-prev-selected', 'moveToNextRow(lambda row,sheet=sheet: sheet.isSelected(row), reverse=True, msg="no previous selected row")', 'go up current column to previous selected row'),
-Sheet.addCommand('}', 'go-next-selected', 'moveToNextRow(lambda row,sheet=sheet: sheet.isSelected(row), msg="no next selected row") ', 'go down current column to next selected row'),
+Sheet.addCommand('<', 'go-prev-value', 'moveToNextRow(lambda row,sheet=sheet,col=cursorCol,val=cursorTypedValue: col.getTypedValue(row) != val, reverse=True, msg="no different value up this column")', 'go up current column to next value')
+Sheet.addCommand('>', 'go-next-value', 'moveToNextRow(lambda row,sheet=sheet,col=cursorCol,val=cursorTypedValue: col.getTypedValue(row) != val, msg="no different value down this column")', 'go down current column to next value')
+Sheet.addCommand('{', 'go-prev-selected', 'moveToNextRow(lambda row,sheet=sheet: sheet.isSelected(row), reverse=True, msg="no previous selected row")', 'go up current column to previous selected row')
+Sheet.addCommand('}', 'go-next-selected', 'moveToNextRow(lambda row,sheet=sheet: sheet.isSelected(row), msg="no next selected row") ', 'go down current column to next selected row')
 
-Sheet.addCommand('z<', 'go-prev-null', 'moveToNextRow(lambda row,col=cursorCol,isnull=isNullFunc(): isnull(col.getValue(row)), reverse=True, msg="no null up this column")', 'go up current column to next null value'),
-Sheet.addCommand('z>', 'go-next-null', 'moveToNextRow(lambda row,col=cursorCol,isnull=isNullFunc(): isnull(col.getValue(row)), msg="no null down this column")', 'go down current column to next null value'),
+Sheet.addCommand('z<', 'go-prev-null', 'moveToNextRow(lambda row,col=cursorCol,isnull=isNullFunc(): isnull(col.getValue(row)), reverse=True, msg="no null up this column")', 'go up current column to next null value')
+Sheet.addCommand('z>', 'go-next-null', 'moveToNextRow(lambda row,col=cursorCol,isnull=isNullFunc(): isnull(col.getValue(row)), msg="no null down this column")', 'go down current column to next null value')
 
 for i in range(1, 11):
     BaseSheet.addCommand(ALT+str(i)[-1], 'jump-sheet-'+str(i), f'vd.push(*(list(s for s in allSheets if s.shortcut==str({i})) or fail("no sheet")))', f'jump to sheet {i}')
@@ -181,9 +170,8 @@ Sheet.addCommand('gzk', 'scroll-cells-top', 'cursorCol.voffset = 0', 'scroll dis
 Sheet.addCommand(None, 'go-end',  'sheet.cursorRowIndex = len(rows)-1; sheet.cursorVisibleColIndex = len(visibleCols)-1', 'go to last row and last column')
 Sheet.addCommand(None, 'go-home', 'sheet.topRowIndex = sheet.cursorRowIndex = 0; sheet.leftVisibleColIndex = sheet.cursorVisibleColIndex = 0', 'go to first row and first column')
 
-BaseSheet.bindkey('CTRL-BUTTON4_PRESSED', 'scroll-left')
-BaseSheet.bindkey('CTRL-REPORT_MOUSE_POSITION', 'scroll-right')
-BaseSheet.bindkey('CTRL-2097152', 'scroll-right')
+BaseSheet.bindkey('Ctrl+ScrollUp', 'scroll-left')
+BaseSheet.bindkey('Ctrl+ScrollDown', 'scroll-right')
 
 BaseSheet.bindkey('zKEY_UP', 'scroll-up')
 BaseSheet.bindkey('zKEY_DOWN', 'scroll-down')
@@ -208,10 +196,30 @@ BaseSheet.bindkey('gl', 'go-rightmost')
 BaseSheet.addCommand('^^', 'jump-prev', 'vd.activeStack[1:] or fail("no previous sheet"); vd.push(vd.activeStack[1])', 'jump to previous sheet in this pane')
 BaseSheet.addCommand('g^^', 'jump-first', 'vd.push(vd.activeStack[-1])', 'jump to first sheet')
 
-BaseSheet.addCommand('BUTTON1_RELEASED', 'no-op', 'pass')
+BaseSheet.addCommand('BUTTON1_RELEASED', 'no-op', 'pass', 'do nothing')
 
 BaseSheet.addCommand(None, 'mouse-enable', 'mm, _ = curses.mousemask(-1); status("mouse "+("ON" if mm else "OFF"))', 'enable mouse events')
 BaseSheet.addCommand(None, 'mouse-disable', 'mm, _ = curses.mousemask(0); status("mouse "+("ON" if mm else "OFF"))', 'disable mouse events')
 
 
 vd.addGlobals({'rotateRange': rotateRange})
+
+vd.addMenuItems('''
+    View > Other sheet > previous sheet > jump-prev
+    View > Other sheet > first sheet > jump-first
+    Column > Goto > by number > go-col-number
+    Column > Goto > by name > go-col-regex
+    Row > Goto > top > go-top
+    Row > Goto > bottom > go-bottom
+    Row > Goto > previous > page > go-pageup
+    Row > Goto > previous > null > go-prev-null
+    Row > Goto > previous > value > go-prev-value
+    Row > Goto > previous > selected > go-prev-selected
+    Row > Goto > next > page > go-pagedown
+    Row > Goto > next > null > go-next-null
+    Row > Goto > next > value > go-next-value
+    Row > Goto > next > selected > go-next-selected
+    Row > Goto > by number > go-row-number
+    View > Other sheet > previous sheet > jump-prev
+    View > Other sheet > first sheet > jump-first
+''')

visidata/optionssheet.py

@@ -0,0 +1,99 @@
+from visidata import vd, VisiData, BaseSheet, Sheet, Column, AttrColumn, CellColorizer, Option
+
+
+@BaseSheet.lazy_property
+def optionsSheet(sheet):
+    return OptionsSheet(sheet.name+"_options", source=sheet)
+
+@VisiData.lazy_property
+def globalOptionsSheet(vd):
+    return OptionsSheet('global_options', source='global')
+
+
+@VisiData.api
+class OptionsSheet(Sheet):
+    _rowtype = Option  # rowdef: Option
+    rowtype = 'options'
+    precious = False
+    columns = (
+        Column('option', getter=lambda col,row: row.name),
+        Column('module', getter=lambda col,row: row.module, max_help=1),
+        Column('value',
+            getter=lambda col,row: col.sheet.diffOption(row.name),
+            setter=lambda col,row,val: col.sheet.source.options.set(row.name, val)
+            ),
+        Column('default', getter=lambda col,row: vd.options.getdefault(row.name)),
+        Column('description', width=40, getter=lambda col,row: vd.options._get(row.name, 'default').helpstr),
+        AttrColumn('replayable', max_help=1),
+    )
+    colorizers = [
+        CellColorizer(3, None, lambda s,c,r,v: v.value if r and c in s.columns[2:4] and r.name.startswith('color_') else None),
+    ]
+    nKeys = 2
+
+    @property
+    def guide(self):
+        if self.source == 'global':
+            r = '# Global Options\nThis is a list of global option settings.'
+        else:
+            r = '# Sheet Options\nThis is a list of option settings specifically for the current sheet.'
+
+        r += f'\n\n- `e` to edit/toggle the current option value'
+        r += '\n- `d` to restore option to builtin default'
+        return r
+
+    def diffOption(self, optname):
+        return vd.options.getonly(optname, self.source, '')
+
+    def editOption(self, row):
+        currentValue = vd.options.getobj(row.name, self.source)
+        vd.addUndo(vd.options.set, row.name, currentValue, self.source)
+        if isinstance(row.value, bool):
+            vd.options.set(row.name, not currentValue, self.source)
+        else:
+            helpstr = f'# options.{self.cursorRow.name}'
+            opt = vd.options._get(self.cursorRow.name, 'default')
+            if opt.helpstr:
+                x = getattr(vd, 'help_'+opt.helpstr, opt.helpstr or '')
+                helpstr += (x or '').strip()
+            if opt.extrahelp:
+                helpstr += '\n'+opt.extrahelp.strip()
+            valcolidx = self.visibleCols.index(self.column(self.valueColName))
+            v = self.editCell(valcolidx, value=currentValue, help=helpstr)
+            vd.options.set(row.name, v, self.source)
+
+    @property
+    def valueColName(self):
+        return 'global_value' if self.source == 'global' else 'sheet_value'
+
+    def beforeLoad(self):
+        super().beforeLoad()
+        self.columns[2].name = self.valueColName
+
+    def iterload(self):
+        for k in vd.options.keys():
+            v = vd.options._get(k)
+#            if vd.options.disp_help > v.max_help:
+#                continue
+            if v.sheettype in [None, BaseSheet]:
+                yield v
+            elif self.source != 'global' and v.sheettype in self.source.superclasses():
+                yield v
+
+    def newRow(self):
+        vd.fail('adding rows to the options sheet is not supported.')
+
+
+BaseSheet.addCommand('O', 'options-global', 'vd.push(vd.globalOptionsSheet)', 'open Options Sheet: edit global options (apply to all sheets)')
+
+BaseSheet.addCommand('zO', 'options-sheet', 'vd.push(sheet.optionsSheet)', 'open Options Sheet: edit sheet options (apply to current sheet only)')
+
+OptionsSheet.addCommand('d', 'unset-option', 'options.unset(cursorRow.name, str(source))', 'remove option override for this context')
+OptionsSheet.addCommand(None, 'edit-option', 'editOption(cursorRow)', 'edit option at current row')
+OptionsSheet.bindkey('e', 'edit-option')
+OptionsSheet.bindkey('Enter', 'edit-option')
+
+vd.addMenuItems('''
+    File > Options > all sheets > options-global
+    File > Options > this sheet > options-sheet
+''')

visidata/path.py

@@ -7,10 +7,46 @@ import pathlib
 from urllib.parse import urlparse, urlunparse
 from functools import wraps, lru_cache
 
-from visidata import *
+from visidata import vd
+from visidata import VisiData, Progress
 
-vd.option('encoding', 'utf-8', 'encoding passed to codecs.open', replay=True)
-vd.option('encoding_errors', 'surrogateescape', 'encoding_errors passed to codecs.open', replay=True)
+vd.help_encoding = '''Common Encodings:
+
+- `utf-8`: Unicode (ASCII compatible, most common)
+- `utf-8-sig`: Unicode as above, but saves/skips leading BOM
+- `ascii`: 7-bit ASCII
+- `latin1`: also known as `iso-8859-1`
+- `cp437`: original IBM PC character set
+- `shift_jis`: Japanese
+
+See [:onclick https://docs.python.org/3/library/codecs.html#standard-encodings]https://docs.python.org/3/library/codecs.html#standard-encodings[/]
+'''
+
+vd.help_encoding_errors = '''Encoding Error Handlers:
+
+- `strict`: raise error
+- `ignore`: discard
+- `replace`: replacement marker
+- `backslashreplace`: use "\\uxxxxxx"
+- `surrogateescape`: use surrogate characters
+
+See [:onclick https://docs.python.org/3/library/codecs.html#error-handlers]https://docs.python.org/3/library/codecs.html#error-handlers[/]
+'''
+
+vd.option('encoding', 'utf-8-sig', 'encoding passed to codecs.open when reading a file', replay=True, help=vd.help_encoding)
+vd.option('encoding_errors', 'surrogateescape', 'encoding_errors passed to codecs.open', replay=True, help=vd.help_encoding_errors)
+
+@VisiData.api
+def pkg_resources_files(vd, package):
+    '''
+    Returns a Traversable object (Path-like), based on the location of the package.
+    importlib.resources.files exists in Python >= 3.9; use importlib_resources for the rest.
+    '''
+    try:
+        from importlib.resources import files
+    except ImportError: #1968
+        from importlib_resources import files
+    return files(package)
 
 @lru_cache()
 def vstat(path, force=False):
@@ -22,7 +58,9 @@ def vstat(path, force=False):
 def filesize(path):
     if hasattr(path, 'filesize') and path.filesize is not None:
         return path.filesize
-    if path.has_fp() or path.is_url():
+    if hasattr(path, 'is_url') and path.is_url():
+        return 0
+    if hasattr(path, 'has_fp') and path.has_fp():
         return 0
     st = path.stat() # vstat(path)
     return st and st.st_size
@@ -38,8 +76,8 @@ class BytesIOWrapper(io.BufferedReader):
 
     def __init__(self, text_io_buffer, encoding=None, errors=None, **kwargs):
         super(BytesIOWrapper, self).__init__(text_io_buffer, **kwargs)
-        self.encoding = encoding or text_io_buffer.encoding or options.encoding
-        self.errors = errors or text_io_buffer.errors or options.encoding_errors
+        self.encoding = encoding or text_io_buffer.encoding or vd.options.encoding
+        self.errors = errors or text_io_buffer.errors or vd.options.encoding_errors
 
     def _encoding_call(self, method_name, *args, **kwargs):
         raw_method = getattr(self.raw, method_name)
@@ -74,11 +112,9 @@ class FileProgress:
         # track Progress on original fp
         self.fp_orig_read = self.fp.read
         self.fp_orig_close = self.fp.close
-        # These two lines result in bug #1159, a corrupted save of corruption formats
-        # for now we are reverting by commenting out, and opened #1175 to investigate
-        # Progress bars for compression formats might not work in the meanwhile
-        #self.fp.read = self.read
-        #self.fp.close = self.close
+
+        self.fp.read = self.read
+        self.fp.close = self.close
 
         if self.prog:
             self.prog.__enter__()
@@ -131,6 +167,11 @@ class Path(os.PathLike):
         self.filesize = filesize
         self.rfile = None
 
+    @property
+    def name(self):
+        'Filename without any extensions.  Not the same as pathlib.Path.'
+        return self.base_stem
+
     @lru_cache()
     def stat(self, force=False):
         return self._path.stat()
@@ -150,15 +191,17 @@ class Path(os.PathLike):
 
         self.ext = self.suffix[1:]
         if self.suffix:  #1450  don't make this a oneliner; [:-0] doesn't work
-            self.name = self._path.name[:-len(self.suffix)]
+            self.base_stem = self._path.name[:-len(self.suffix)]
+        elif self._given == '.':  #1768
+            self.base_stem = self._path.absolute().name
         else:
-            self.name = self._path.name
+            self.base_stem = self._path.name
 
         # check if file is compressed
         if self.suffix in ['.gz', '.bz2', '.xz', '.lzma', '.zst']:
             self.compression = self.ext
             uncompressedpath = Path(self.given[:-len(self.suffix)])  # strip suffix
-            self.name = uncompressedpath.name
+            self.base_stem = uncompressedpath.base_stem
             self.ext = uncompressedpath.ext
         else:
             self.compression = None
@@ -190,23 +233,26 @@ class Path(os.PathLike):
         'Return True if this is a virtual Path to an already open file.'
         return bool(self.fp or self.fptext)
 
-    def open_text(self, mode='rt', encoding=None, encoding_errors=None, newline=None):
-        'Open path in text mode, using options.encoding and options.encoding_errors.  Return open file-pointer or file-pointer-like.'
+    def open(self, mode='rt', encoding=None, encoding_errors=None, newline=None):
+        'Open path in text or binary mode, using options.encoding and options.encoding_errors.  Return open file-pointer or file-pointer-like.'
         # rfile makes a single-access fp reusable
 
         if self.rfile:
-            return self.rfile
+            if 'b' in mode:
+                raise ValueError('a RepeatFile holds text and cannot be reopened in binary mode')
+            return self.rfile.reopen()
 
         if self.fp:
-            self.fptext = codecs.iterdecode(self.fp,
-                                            encoding=encoding or options.encoding,
-                                            errors=encoding_errors or options.encoding_errors)
+            if 'b' not in mode:
+                self.fptext = codecs.iterdecode(self.fp,
+                                                encoding=encoding or vd.options.encoding,
+                                                errors=encoding_errors or vd.options.encoding_errors)
 
         if self.fptext:
             self.rfile = RepeatFile(self.fptext)
             return self.rfile
 
-        if 't' not in mode:
+        if 't' not in mode and 'b' not in mode:
             mode += 't'
 
         if self.given == '-':
@@ -216,18 +262,21 @@ class Path(os.PathLike):
                 # convert 'a' to 'w' for stdout: https://bugs.python.org/issue27805
                 return open(os.dup(vd._stdout.fileno()), 'wt')
             else:
-                vd.error('invalid mode "%s" for Path.open_text()' % mode)
+                vd.error('invalid mode "%s" for Path.open()' % mode)
                 return sys.stderr
 
-        return self.open(mode=mode, encoding=encoding or vd.options.encoding, errors=vd.options.encoding_errors, newline=newline)
+        if 'b' in mode:
+            return self._open(mode=mode)
+        else:
+            return self._open(mode=mode, encoding=encoding or vd.options.encoding, errors=vd.options.encoding_errors, newline=newline)
 
     @wraps(pathlib.Path.read_text)
     def read_text(self, *args, **kwargs):
         'Open the file in text mode and return its entire decoded contents.'
         if 'encoding' not in kwargs:
-            kwargs['encoding'] = options.encoding
+            kwargs['encoding'] = vd.options.encoding
         if 'errors' not in kwargs:
-            kwargs['errors'] = kwargs.get('encoding_errors', options.encoding_errors)
+            kwargs['errors'] = kwargs.get('encoding_errors', vd.options.encoding_errors)
 
         if self.lines:
             return RepeatFile(self.lines).read()
@@ -237,7 +286,7 @@ class Path(os.PathLike):
             return self._path.read_text(*args, **kwargs)
 
     @wraps(pathlib.Path.open)
-    def open(self, *args, **kwargs):
+    def _open(self, *args, **kwargs):
         if self.fp:
             return FileProgress(self, fp=self.fp, **kwargs)
 
@@ -245,25 +294,32 @@ class Path(os.PathLike):
             return FileProgress(self, fp=BytesIOWrapper(self.fptext), **kwargs)
 
         path = self
-        binmode = 'wb' if 'w' in kwargs.get('mode', '') else 'rb'
+
         if self.compression == 'gz':
             import gzip
-            return gzip.open(FileProgress(path, fp=open(path, mode=binmode), **kwargs), *args, **kwargs)
+            zopen = gzip.open
         elif self.compression == 'bz2':
             import bz2
-            return bz2.open(FileProgress(path, fp=open(path, mode=binmode), **kwargs), *args, **kwargs)
+            zopen = bz2.open
         elif self.compression in ['xz', 'lzma']:
             import lzma
-            return lzma.open(FileProgress(path, fp=open(path, mode=binmode), **kwargs), *args, **kwargs)
+            zopen = lzma.open
         elif self.compression == 'zst':
-            import zstandard
-            return zstandard.open(FileProgress(path, fp=open(path, mode=binmode), **kwargs), *args, **kwargs)
+            zstandard = vd.importExternal('zstandard')
+            zopen = zstandard.open
         else:
             return FileProgress(path, fp=self._path.open(*args, **kwargs), **kwargs)
 
+        if 'w' in kwargs.get('mode', ''):
+            #1159 FileProgress on the outside to close properly when writing
+            return FileProgress(path, fp=zopen(path, **kwargs), **kwargs)
+
+        #1255 FileProgress on the inside to track uncompressed bytes when reading
+        return zopen(FileProgress(path, fp=open(path, mode='rb'), **kwargs), **kwargs)
+
     def __iter__(self):
         with Progress(total=filesize(self)) as prog:
-            with self.open_text(encoding=vd.options.encoding) as fd:
+            with self.open(encoding=vd.options.encoding) as fd:
                 for i, line in enumerate(fd):
                     prog.addProgress(len(line))
                     yield line.rstrip('\n')
@@ -272,13 +328,22 @@ class Path(os.PathLike):
         'Open the file pointed by this path and return a file object in binary mode.'
         if 'b' not in mode:
             mode += 'b'
-        return self.open(mode=mode)
+        return self.open(mode=mode)  #1880
 
     def read_bytes(self):
         'Return the entire binary contents of the pointed-to file as a bytes object.'
         with self.open(mode='rb') as fp:
             return fp.read()
 
+    @wraps(pathlib.Path.is_fifo)
+    def is_fifo(self):
+        'Return True if the path is a file.'
+        return self._path.is_fifo()
+
+    def is_local(self):
+        'Return True if self.filename refers to a file on the local disk.'
+        return not bool(self.fp) and not bool(self.fptext)
+
     def is_url(self):
         'Return True if the given path appears to be a URL.'
         return '://' in self.given
@@ -315,10 +380,10 @@ class Path(os.PathLike):
         'Return a sibling Path with *name* as a filename in the same directory.'
         if self.is_url():
             urlparts = list(urlparse(self.given))
-            urlparts[2] = '/'.join(Path(urlparts[2])._parts[1:-1] + [name])
+            urlparts[2] = '/'.join(list(Path(urlparts[2]).parts[1:-1]) + [name])
             return Path(urlunparse(urlparts))
         else:
-            return Path(self._from_parsed_parts(self._drv, self._root, self._parts[:-1] + [name]))
+            return Path(self._from_parsed_parts(self._drv, self._root, list(self.parts[:-1]) + [name]))
 
 
 class RepeatFile:
@@ -331,22 +396,31 @@ class RepeatFile:
 
     def __enter__(self):
         '''Returns a new independent file-like object, sharing the same line cache.'''
-        return RepeatFile(self.iter_lines, lines=self.lines)
+        return self.reopen()
 
     def __exit__(self, a,b,c):
         pass
 
+    def reopen(self):
+        'Return copy of file-like with internal iterator reset.'
+        return RepeatFile(self.iter_lines, lines=self.lines)
+
     def read(self, n=None):
-        r = ''
+        r = None
         if n is None:
             n = 10**12  # some too huge number
-        while len(r) < n:
+        while r is None or len(r) < n:
             try:
                 s = next(self.iter)
-                r += s + '\n'
+                if r is None:
+                    r = '' if isinstance(s, str) else b''
+                else:
+                    assert isinstance(r, type(s)), (r, type(s))
+
+                r += s + '\n' if isinstance(s, str) else b'\n'
             except StopIteration:
                 break  # end of file
-        return r
+        return r or ''
 
     def write(self, s):
         return self.iter_lines.write(s)
@@ -355,9 +429,16 @@ class RepeatFile:
         '''Tells the current position as an opaque line marker.'''
         return self.iter.nextIndex
 
-    def seek(self, n):
+    def seek(self, offset, whence=io.SEEK_SET):
         '''Seek to an already seen opaque line position marker only.'''
-        self.iter.nextIndex = n
+        if whence != io.SEEK_SET and offset != 0:
+            if whence == io.SEEK_CUR:
+                raise io.UnsupportedOperation("can't do nonzero cur-relative seeks")
+            elif whence == io.SEEK_END:
+                raise io.UnsupportedOperation("can't do nonzero end-relative seeks")
+            else:
+                raise ValueError('invalid whence (%s, should be %s, %s or %s)' % (whence, io.SEEK_SET, io.SEEK_CUR, io.SEEK_END))
+        self.iter.nextIndex = offset
 
     def readline(self, size=-1):
         if size != -1:
@@ -401,3 +482,10 @@ class RepeatFileIter:
 
         self.nextIndex += 1
         return r
+
+
+vd.addGlobals(RepeatFile=RepeatFile,
+              Path=Path,
+              modtime=modtime,
+              filesize=filesize,
+              vstat=vstat)