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

visidata/_types.py

@@ -53,9 +53,8 @@ def numericFormatter(vd, fmtstr, typedval):
 def numericType(vd, icon='', fmtstr='', formatter=vd.numericFormatter):
     '''Decorator for numeric types.'''
     def _decorator(f):
-        vd.addType(f, icon=icon, fmtstr=fmtstr, formatter=formatter)
+        vd.addType(f, icon=icon, fmtstr=fmtstr, formatter=formatter, name=f.__name__)
         vd.numericTypes.append(f)
-        vd.addGlobals({f.__name__: f})
         return f
     return _decorator
 
@@ -82,6 +81,8 @@ def addType(vd, typetype=None, icon=None, fmtstr='', formatter=vd.numericFormatt
     t = VisiDataType(typetype=typetype, icon=icon, fmtstr=fmtstr, formatter=formatter, key=key, name=name)
     if typetype:
         vd.typemap[typetype] = t
+        if name:
+            vd.addGlobals({name: typetype})
     return t
 
 vdtype = vd.addType
@@ -94,7 +95,7 @@ vd.typemap = {}
 def getType(vd, typetype):
     return vd.typemap.get(typetype) or VisiDataType()
 
-vdtype(None, '∅')
+vdtype(None, '∅', name='none')
 vdtype(anytype, '', formatter=lambda _,v: str(v))
 vdtype(str, '~', formatter=lambda _,v: v)
 vdtype(int, '#')

visidata/aggregators.py

@@ -5,7 +5,7 @@ import collections
 import statistics
 
 from visidata import Progress, Sheet, Column, ColumnsSheet, VisiData
-from visidata import vd, anytype, vlen, asyncthread, wrapply, AttrDict
+from visidata import vd, anytype, vlen, asyncthread, wrapply, AttrDict, date, INPROGRESS
 
 vd.help_aggregators = '''# Choose Aggregators
 Start typing an aggregator name or description.
@@ -48,10 +48,15 @@ def getValues(self, rows):
 vd.aggregators = collections.OrderedDict()  # [aggname] -> annotated func, or list of same
 
 Column.init('aggstr', str, copy=True)
+Column.init('_aggregatedTotals', dict)  # [aggname] -> agg total over all rows
 
 def aggregators_get(col):
     'A space-separated names of aggregators on this column.'
-    return list(vd.aggregators[k] for k in (col.aggstr or '').split())
+    aggs = []
+    for k in (col.aggstr or '').split():
+        agg = vd.aggregators[k]
+        aggs += agg if isinstance(agg, list) else [agg]
+    return aggs
 
 def aggregators_set(col, aggs):
     if isinstance(aggs, str):
@@ -71,32 +76,28 @@ Column.aggregators = property(aggregators_get, aggregators_set)
 
 
 class Aggregator:
-    def __init__(self, name, type, funcRows, funcValues=None, helpstr='foo'):
-        'Define aggregator `name` that calls func(col, rows)'
+    def __init__(self, name, type, funcValues=None, helpstr='foo'):
+        'Define aggregator `name` that calls funcValues(values)'
         self.type = type
-        self.func = funcRows  # funcRows(col, rows)
-        self.funcValues = funcValues  # funcValues(values, *args)
+        self.funcValues = funcValues  # funcValues(values)
         self.helpstr = helpstr
         self.name = name
 
-    def __call__(self, *args, **kwargs):
-        return self.func(*args, **kwargs)
-
-_defaggr = Aggregator
-
-@VisiData.api
-def aggregator(vd, name, funcValues, helpstr='', *args, type=None):
-    'Define simple aggregator *name* that calls ``funcValues(values, *args)`` to aggregate *values*.  Use *type* to force the default type of the aggregated column.'
-    def _funcRows(col, rows):  # wrap builtins so they can have a .type
+    def aggregate(self, col, rows):  # wrap builtins so they can have a .type
         vals = list(col.getValues(rows))
         try:
-            return funcValues(vals, *args)
+            return self.funcValues(vals)
         except Exception as e:
             if len(vals) == 0:
                 return None
-            return e
+            raise e
 
-    vd.aggregators[name] = _defaggr(name, type, _funcRows, funcValues=funcValues, helpstr=helpstr)  # accepts a srccol + list of rows
+
+@VisiData.api
+def aggregator(vd, name, funcValues, helpstr='', *, type=None):
+    '''Define simple aggregator *name* that calls ``funcValues(values)`` to aggregate *values*.
+       Use *type* to force type of aggregated column (default to use type of source column).'''
+    vd.aggregators[name] = Aggregator(name, type, funcValues=funcValues, helpstr=helpstr)
 
 ## specific aggregator implementations
 
@@ -105,12 +106,9 @@ def mean(vals):
     if vals:
         return float(sum(vals))/len(vals)
 
-def _vsum(vals):
+def vsum(vals):
     return sum(vals, start=type(vals[0] if len(vals) else 0)())  #1996
 
-# start parameter in sum() added in Python 3.8
-vsum = _vsum if sys.version_info[:2] >= (3, 8) else sum
-
 # http://code.activestate.com/recipes/511478-finding-the-percentile-of-the-values/
 def _percentile(N, percent, key=lambda x:x):
     """
@@ -134,11 +132,18 @@ def _percentile(N, percent, key=lambda x:x):
     return d0+d1
 
 @functools.lru_cache(100)
-def percentile(pct, helpstr=''):
-    return _defaggr('p%s'%pct, None, lambda col,rows,pct=pct: _percentile(sorted(col.getValues(rows)), pct/100), helpstr=helpstr)
+class PercentileAggregator(Aggregator):
+    def __init__(self, pct, helpstr=''):
+        super().__init__('p%s'%pct, None, helpstr=helpstr)
+        self.pct = pct
+
+    def aggregate(self, col, rows):
+        return _percentile(sorted(col.getValues(rows)), self.pct/100, key=float)
+
 
 def quantiles(q, helpstr):
-    return [percentile(round(100*i/q), helpstr) for i in range(1, q)]
+    return [PercentileAggregator(round(100*i/q), helpstr) for i in range(1, q)]
+
 
 vd.aggregator('min', min, 'minimum value')
 vd.aggregator('max', max, 'maximum value')
@@ -149,7 +154,7 @@ vd.aggregator('mode', statistics.mode, 'mode of values')
 vd.aggregator('sum', vsum, 'sum of values')
 vd.aggregator('distinct', set, 'distinct values', type=vlen)
 vd.aggregator('count', lambda values: sum(1 for v in values), 'number of values', type=int)
-vd.aggregator('list', list, 'list of values')
+vd.aggregator('list', list, 'list of values', type=anytype)
 vd.aggregator('stdev', statistics.stdev, 'standard deviation of values', type=float)
 
 vd.aggregators['q3'] = quantiles(3, 'tertiles (33/66th pctile)')
@@ -160,10 +165,31 @@ vd.aggregators['q10'] = quantiles(10, 'deciles (10/20/30/40/50/60/70/80/90th pct
 # since bb29b6e, a record of every aggregator
 # is needed in vd.aggregators
 for pct in (10, 20, 25, 30, 33, 40, 50, 60, 67, 70, 75, 80, 90, 95, 99):
-    vd.aggregators[f'p{pct}'] = percentile(pct, f'{pct}th percentile')
+    vd.aggregators[f'p{pct}'] = PercentileAggregator(pct, f'{pct}th percentile')
+
+class KeyFindingAggregator(Aggregator):
+    '''Return the key of the row that results from applying *aggr_func* to *rows*.
+        Return None if *rows* is an empty list.
+        *aggr_func* takes a list of (value, row) tuples, one for each row in the column,
+        excluding rows where the column holds null and error values.
+        *aggr_func* must also take the parameters *default* and *key*, as max() does:
+        https://docs.python.org/3/library/functions.html#max'''
 
-# returns keys of the row with the max value
-vd.aggregators['keymax'] = _defaggr('keymax', anytype, lambda col, rows: col.sheet.rowkey(max(col.getValueRows(rows))[1]), helpstr='key of the maximum value')
+    def __init__(self, aggr_func, *args, **kwargs):
+        self.aggr_func = aggr_func
+        super().__init__(*args, **kwargs)
+
+    def aggregate(self, col, rows):
+        if not col.sheet.keyCols:
+            vd.error('key aggregator function requires one or more key columns')
+            return None
+        # convert dicts to lists because functions like max() can't compare dicts
+        sortkey = lambda t: (t[0], sorted(t[1].items())) if isinstance(t[1], dict) else t
+        row = self.aggr_func(col.getValueRows(rows), default=(None, None), key=sortkey)[1]
+        return col.sheet.rowkey(row) if row else None
+
+vd.aggregators['keymin'] = KeyFindingAggregator(min, 'keymin', anytype, helpstr='key of the minimum value')
+vd.aggregators['keymax'] = KeyFindingAggregator(max, 'keymax', anytype, helpstr='key of the maximum value')
 
 
 ColumnsSheet.columns += [
@@ -175,7 +201,7 @@ ColumnsSheet.columns += [
 
 @Sheet.api
 def addAggregators(sheet, cols, aggrnames):
-    'Add each aggregator in list of *aggrnames* to each of *cols*.'
+    'Add each aggregator in list of *aggrnames* to each of *cols*. Ignores names that are not valid.'
     for aggrname in aggrnames:
         aggrs = vd.aggregators.get(aggrname)
         aggrs = aggrs if isinstance(aggrs, list) else [aggrs]
@@ -192,16 +218,35 @@ def aggname(col, agg):
     'Consistent formatting of the name of given aggregator for this column.  e.g. "col1_sum"'
     return '%s_%s' % (col.name, agg.name)
 
+@Column.api
+def aggregateTotal(col, agg):
+    if agg not in col._aggregatedTotals:
+        col._aggregatedTotals[agg] = INPROGRESS
+        col._aggregateTotalAsync(agg)
+    return col._aggregatedTotals[agg]
+
+
+@Column.api
+@asyncthread
+def _aggregateTotalAsync(col, agg):
+    col._aggregatedTotals[agg] = agg.aggregate(col, col.sheet.rows)
+
+
 @Column.api
 @asyncthread
-def memo_aggregate(col, agg, rows):
+def memo_aggregate(col, agg_choices, rows):
     'Show aggregated value in status, and add to memory.'
-    aggval = agg(col, rows)
-    typedval = wrapply(agg.type or col.type, aggval)
-    dispval = col.format(typedval)
-    k = col.name+'_'+agg.name
-    vd.status(f'{k}={dispval}')
-    vd.memory[k] = typedval
+    for agg_choice in agg_choices:
+        agg = vd.aggregators.get(agg_choice)
+        if not agg: continue
+        aggs = agg if isinstance(agg, list) else [agg]
+        for agg in aggs:
+            aggval = agg.aggregate(col, rows)
+            typedval = wrapply(agg.type or col.type, aggval)
+            dispval = col.format(typedval)
+            k = col.name+'_'+agg.name
+            vd.status(f'{k}={dispval}')
+            vd.memory[k] = typedval
 
 
 @VisiData.property
@@ -215,6 +260,7 @@ def aggregator_choices(vd):
 
 @VisiData.api
 def chooseAggregators(vd):
+    '''Return a list of aggregator name strings chosen or entered by the user. User-entered names may be invalid.'''
     prompt = 'choose aggregators: '
     def _fmt_aggr_summary(match, row, trigger_key):
         formatted_aggrname = match.formatted.get('key', row.key) if match else row.key
@@ -235,12 +281,15 @@ def chooseAggregators(vd):
             multiple=True)
 
     aggrs = r.split()
+    valid_choices = vd.aggregators.keys()
     for aggr in aggrs:
         vd.usedInputs[aggr] += 1
+        if aggr not in valid_choices:
+            vd.warning(f'aggregator does not exist: {aggr}')
     return aggrs
 
-Sheet.addCommand('+', 'aggregate-col', 'addAggregators([cursorCol], chooseAggregators())', 'Add aggregator to current column')
-Sheet.addCommand('z+', 'memo-aggregate', 'for agg in chooseAggregators(): cursorCol.memo_aggregate(aggregators[agg], selectedRows or rows)', 'memo result of aggregator over values in selected rows for current column')
+Sheet.addCommand('+', 'aggregate-col', 'addAggregators([cursorCol], chooseAggregators())', 'add aggregator to current column')
+Sheet.addCommand('z+', 'memo-aggregate', 'cursorCol.memo_aggregate(chooseAggregators(), selectedRows or rows)', 'memo result of aggregator over values in selected rows for current column')
 ColumnsSheet.addCommand('g+', 'aggregate-cols', 'addAggregators(selectedRows or source[0].nonKeyVisibleCols, chooseAggregators())', 'add aggregators to selected source columns')
 
 vd.addMenuItems('''

visidata/apps/vdsql/_ibis.py

@@ -60,6 +60,8 @@ def configure_ibis(vd):
 
 @VisiData.api
 def open_vdsql(vd, p, filetype=None):
+    import ibis
+
     vd.configure_ibis()
 
     # on-demand aliasing, so we don't need deps for all backends
@@ -70,7 +72,9 @@ def open_vdsql(vd, p, filetype=None):
     return IbisTableIndexSheet(p.base_stem, source=p, filetype=None, database_name=None,
                                ibis_conpool=IbisConnectionPool(p), sheet_type=IbisTableSheet)
 
+
 vd.open_ibis = vd.open_vdsql
+vd.openurl_sqlite = vd.open_vdsql
 
 
 class IbisConnectionPool:
@@ -85,14 +89,8 @@ class IbisConnectionPool:
     @contextmanager
     def get_conn(self):
         if not self.pool:
-            import sqlalchemy
-            try:
-                import ibis
-                r = ibis.connect(str(self.source))
-            except sqlalchemy.exc.NoSuchModuleError as e:
-                dialect = str(e).split(':')[-1]
-                vd.warning(f'{dialect} not installed')
-                vd.fail(f'pip install ibis-framework[{dialect}]')
+            import ibis
+            r = ibis.connect(str(self.source))
         else:
             r = self.pool.pop(0)
 
@@ -210,9 +208,9 @@ class IbisTableSheet(Sheet):
     def curcol_sql(self):
         expr = self.cursorCol.get_ibis_col(self.ibis_current_expr)
         if expr is not None:
-            return self.ibis_to_sql(expr, fragment=True)
+            return self.ibis_expr_to_sql(expr, fragment=True)
 
-    def ibis_to_sql(self, expr, fragment=False):
+    def ibis_expr_to_sql(self, expr, fragment=False):
         import sqlparse
         with self.con as con:
             context = con.compiler.make_context()
@@ -323,7 +321,7 @@ class IbisTableSheet(Sheet):
     def sqlize(self, expr):
         if vd.options.debug:
             expr = self.withRowcount(expr)
-        return self.ibis_to_sql(expr)
+        return self.ibis_expr_to_sql(expr)
 
     @property
     def substrait(self):

visidata/apps/vdsql/clickhouse.py

@@ -1,6 +1,6 @@
 import time
 
-from visidata import BaseException, vd, VisiData, Progress
+from visidata import vd, VisiData, Progress
 
 from ._ibis import IbisTableSheet, IbisTableIndexSheet, IbisConnectionPool
 
@@ -45,7 +45,7 @@ class ClickhouseSheet(IbisTableSheet):
                 raise
             except BaseException:
                 if qid:
-                    con.con.cancel(qid)
+                    con._client.cancel(qid)
 
 
 ClickhouseSheet.init('total_rows', lambda: None)

visidata/apps/vdsql/snowflake.py

@@ -1,6 +1,6 @@
 import time
 
-from visidata import vd, BaseException, VisiData
+from visidata import vd, VisiData
 
 from ._ibis import IbisTableSheet, IbisConnectionPool, IbisTableIndexSheet
 

visidata/apps/vgit/status.py

@@ -112,7 +112,7 @@ class GitStatus(GitSheet):
         return self.gitBranchStatuses.get(self.branch, 'no branch')
 
     def iterload(self):
-        files = [GitFile(p, self.source) for p in self.source.iterdir() if p.base_stem not in ('.git')]  # files in working dir
+        files = [GitFile(p, self.source) for p in self.source.iterdir() if p.stem not in ('.git')]  # files in working dir
 
         filenames = dict((gf.filename, gf) for gf in files)
 

visidata/basesheet.py

@@ -67,6 +67,10 @@ class DrawablePane(Extensible):
         'Width of the current sheet window, in single-width characters.'
         return self._scr.getmaxyx()[1] if self._scr else 80
 
+    @property
+    def currow(self):
+        return None
+
     def execCommand2(self, cmd, vdglobals=None):
         "Execute `cmd` with `vdglobals` as globals and this sheet's attributes as locals.  Return True if user cancelled."
 
@@ -112,9 +116,9 @@ class BaseSheet(DrawablePane):
 
     def __init__(self, *names, rows=UNLOADED, **kwargs):
         self._name = None   # initial cache value necessary for self.options
+        self._names = []
         self.loading = False
         self.names = list(names)
-        self.name = self.options.name_joiner.join(str(x) for x in self.names if x)
         self.source = None
         self.rows = rows      # list of opaque objects
         self._scr = None
@@ -194,7 +198,7 @@ class BaseSheet(DrawablePane):
 
         cmd = self.getCommand(longname or keystrokes)
         if not cmd:
-            vd.warning('no command for %s' % (longname or keystrokes))
+            vd.fail('no command for %s' % (longname or keystrokes))
             return False
 
         escaped = False
@@ -238,8 +242,10 @@ class BaseSheet(DrawablePane):
 
     @names.setter
     def names(self, names):
+        if self._names:
+            vd.addUndo(setattr, self, 'names', self._names)
         self._names = names
-        self.name = self.options.name_joiner.join(self.maybeClean(str(x)) for x in self._names)
+        self._name = self.options.name_joiner.join(self.maybeClean(str(x)) for x in self._names)
 
     @property
     def name(self):
@@ -250,8 +256,9 @@ class BaseSheet(DrawablePane):
     def name(self, name):
         'Set name without spaces.'
         if self._names:
-            vd.addUndo(setattr, self, '_names', self._names)
+            vd.addUndo(setattr, self, 'names', self._names)
         self._name = self.maybeClean(str(name))
+        self._names = [self._name]
 
     def maybeClean(self, s):
         'stub'

visidata/canvas.py

@@ -145,7 +145,7 @@ class Plotter(BaseSheet):
         self.labels = []  # (x, y, text, attr, row)
         self.hiddenAttrs = set()
         self.needsRefresh = False
-        self.resetCanvasDimensions(self.windowHeight, self.windowWidth)
+        self.resetCanvasDimensions(1, 1)  #2171
 
     @property
     def nRows(self):
@@ -209,15 +209,23 @@ class Plotter(BaseSheet):
             self.hiddenAttrs.remove(attr)
         self.plotlegends()
 
-    def rowsWithin(self, plotter_bbox):
+    def rowsWithin(self, plotter_bbox, invert_y=False):
         'return list of deduped rows within plotter_bbox'
         ret = {}
+
         x_start = max(0, plotter_bbox.xmin)
+        if len(self.pixels) == 0: return []
+        x_end = min(len(self.pixels[0]), plotter_bbox.xmax)
+
         y_start = max(0, plotter_bbox.ymin)
         y_end = min(len(self.pixels), plotter_bbox.ymax)
-        for y in range(y_start, y_end):
-            x_end = min(len(self.pixels[y]), plotter_bbox.xmax)
-            for x in range(x_start, x_end):
+        if invert_y:
+            y_range = range(y_end-1, y_start-1, -1)
+        else:
+            y_range = range(y_start, y_end)
+
+        for x in range(x_start, x_end):
+            for y in y_range:
                 for attr, rows in self.pixels[y][x].items():
                     if attr not in self.hiddenAttrs:
                         for r in rows:
@@ -226,12 +234,28 @@ class Plotter(BaseSheet):
 
     def draw(self, scr):
         windowHeight, windowWidth = scr.getmaxyx()
-        disp_canvas_charset = self.options.disp_canvas_charset or ' o'
-        disp_canvas_charset += (256 - len(disp_canvas_charset)) * disp_canvas_charset[-1]
-
         if self.needsRefresh:
             self.render(windowHeight, windowWidth)
 
+        self.draw_pixels(scr)
+        self.draw_labels(scr)
+
+    def draw_empty(self, scr):
+        # use draw_empty() when calling draw_pixels() with clear_empty_squares=False
+        cursorBBox = self.plotterCursorBox
+        for char_y in range(0, self.plotheight//4):
+            for char_x in range(0, self.plotwidth//2):
+                cattr = ColorAttr()
+                ch = ' '
+                # draw cursor
+                if cursorBBox.contains(char_x*2, char_y*4) or \
+                    cursorBBox.contains(char_x*2+1, char_y*4+3):
+                    cattr = update_attr(cattr, colors.color_current_row)
+                scr.addstr(char_y, char_x, ch, cattr.attr)
+
+    def draw_pixels(self, scr, clear_empty_squares=True):
+        disp_canvas_charset = self.options.disp_canvas_charset or ' o'
+        disp_canvas_charset += (256 - len(disp_canvas_charset)) * disp_canvas_charset[-1]
         if self.pixels:
             cursorBBox = self.plotterCursorBox
             getPixelAttr = self.getPixelAttrRandom if self.options.disp_pixel_random else self.getPixelAttrMost
@@ -256,19 +280,26 @@ class Plotter(BaseSheet):
                             braille_num += pow2
                         pow2 *= 2
 
+                    ch = disp_canvas_charset[braille_num]
                     if braille_num != 0:
                         color = Counter(c for c in block_attrs if c).most_common(1)[0][0]
                         cattr = colors.get_color(color)
                     else:
                         cattr = ColorAttr()
+                        # don't erase empty squares, useful for subclasses that draw elements like reflines
+                        # before pixels are drawn
+                        if not clear_empty_squares:
+                            continue
 
+                    # draw cursor
                     if cursorBBox.contains(char_x*2, char_y*4) or \
                        cursorBBox.contains(char_x*2+1, char_y*4+3):
                         cattr = update_attr(cattr, colors.color_current_row)
 
                     if cattr.attr:
-                        scr.addstr(char_y, char_x, disp_canvas_charset[braille_num], cattr.attr)
+                        scr.addstr(char_y, char_x, ch, cattr.attr)
 
+    def draw_labels(self, scr):
         def _mark_overlap_text(labels, textobj):
             def _overlaps(a, b):
                 a_x1, _, a_txt, _, _ = a
@@ -310,7 +341,7 @@ class Plotter(BaseSheet):
                         cursorBBox = self.plotterCursorBox
                         for c in txt:
                             w = dispwidth(c)
-                            # check if the cursor contains the midpoint of the character box
+                            # draw cursor if the cursor contains the midpoint of the character cell
                             if cursorBBox.contains(char_x*2+1, char_y*4+2):
                                 char_attr = update_attr(cattr, colors.color_current_row)
                                 clipdraw(scr, char_y, char_x, c, char_attr, w)
@@ -385,6 +416,12 @@ class Canvas(Plotter):
                 if self.cursorBox.xmin == self.visibleBox.xmin and self.cursorBox.ymin == self.calcBottomCursorY():
                     realign_cursor = True
         super().resetCanvasDimensions(windowHeight, windowWidth)
+        # if window is not big enough to contain a particular margin, pretend that margin is 0
+        pvbox_x = pvbox_y = 0
+        if self.plotwidth > self.left_margin:
+            pvbox_x = self.left_margin
+        if self.plotheight > self.topMarginPixels:
+            pvbox_y = self.topMarginPixels
         if hasattr(self, 'legendwidth'):
             # +4 = 1 empty space after the graph + 2 characters for the legend prefixes of "1:", "2:", etc +
             #      1 character for the empty rightmost column
@@ -395,8 +432,10 @@ class Canvas(Plotter):
         else:
             pvbox_xmax = self.plotwidth-self.rightMarginPixels-1
         self.left_margin = min(self.left_margin, math.ceil(self.plotwidth * 1/3)//2*2)
-        self.plotviewBox = BoundingBox(self.left_margin, self.topMarginPixels,
-                                       pvbox_xmax, self.plotheight-self.bottomMarginPixels-1)
+        # enforce a minimum plotview box size of 1x1
+        pvbox_xmax = max(pvbox_xmax, 1)
+        pvbox_ymax = max(self.plotheight-self.bottomMarginPixels-1, 1)
+        self.plotviewBox = BoundingBox(pvbox_x, pvbox_y, pvbox_xmax, pvbox_ymax)
         if [self.plotheight, self.plotwidth] != old_plotsize:
             if hasattr(self, 'cursorBox') and self.cursorBox:
                 self.setCursorSizeInPlotterPixels(2, 4)
@@ -513,13 +552,14 @@ class Canvas(Plotter):
         'adjust visibleBox.xymin so that canvasPoint is plotted at plotterPoint'
         self.visibleBox.xmin = canvasPoint.x - self.canvasW(plotterPoint.x-self.plotviewBox.xmin)
         self.visibleBox.ymin = canvasPoint.y - self.canvasH(plotterPoint.y-self.plotviewBox.ymin)
-        self.refresh()
+        self.resetBounds()
 
     def zoomTo(self, bbox):
         'set visible area to bbox, maintaining aspectRatio if applicable'
         self.fixPoint(self.plotviewBox.xymin, bbox.xymin)
         self.xzoomlevel=bbox.w/self.canvasBox.w
         self.yzoomlevel=bbox.h/self.canvasBox.h
+        self.resetBounds()
 
     def incrZoom(self, incr):
         self.xzoomlevel *= incr
@@ -527,7 +567,7 @@ class Canvas(Plotter):
 
         self.resetBounds()
 
-    def resetBounds(self):
+    def resetBounds(self, refresh=True):
         'create canvasBox and cursorBox if necessary, and set visibleBox w/h according to zoomlevels.  then redisplay legends.'
         if not self.canvasBox:
             xmin, ymin, xmax, ymax = None, None, None, None
@@ -564,6 +604,8 @@ class Canvas(Plotter):
             self.cursorBox = Box(cb_xmin, cb_ymin, self.canvasCharWidth, self.canvasCharHeight)
 
         self.plotlegends()
+        if refresh:
+            self.refresh()
 
     def calcTopCursorY(self):
         'ymin for the cursor that will align its top with the top edge of the graph'
@@ -641,13 +683,13 @@ class Canvas(Plotter):
         else:
             return h
 
-    def scaleX(self, canvasX):
+    def scaleX(self, canvasX) -> int:
         'returns a plotter x coordinate'
-        return round(self.plotviewBox.xmin+(canvasX-self.visibleBox.xmin)*self.xScaler)
+        return self.plotviewBox.xmin+round((canvasX-self.visibleBox.xmin)*self.xScaler)
 
-    def scaleY(self, canvasY):
+    def scaleY(self, canvasY) -> int:
         'returns a plotter y coordinate'
-        return round(self.plotviewBox.ymin+(canvasY-self.visibleBox.ymin)*self.yScaler)
+        return self.plotviewBox.ymin+round((canvasY-self.visibleBox.ymin)*self.yScaler)
 
     def unscaleX(self, plotterX):
         'performs the inverse of scaleX, returns a canvas x coordinate'
@@ -675,6 +717,7 @@ class Canvas(Plotter):
         vd.cancelThread(*(t for t in self.currentThreads if t.name == 'plotAll_async'))
         self.labels.clear()
         self.resetCanvasDimensions(h, w)
+        self.resetBounds(refresh=False)
         self.render_async()
 
     @asyncthread
@@ -701,12 +744,12 @@ class Canvas(Plotter):
                 x1, y1 = float(x1), float(y1)
                 if xmin <= x1 <= xmax and ymin <= y1 <= ymax:
                     # equivalent to self.scaleX(x1) and self.scaleY(y1), inlined for speed
-                    x = plotxmin+(x1-xmin)*xfactor
+                    x = plotxmin+round((x1-xmin)*xfactor)
                     if invert_y:
-                        y = plotymax-(y1-ymin)*yfactor
+                        y = plotymax-round((y1-ymin)*yfactor)
                     else:
-                        y = plotymin+(y1-ymin)*yfactor
-                    self.plotpixel(round(x), round(y), attr, row)
+                        y = plotymin+round((y1-ymin)*yfactor)
+                    self.plotpixel(x, y, attr, row)
                 continue
 
             prev_x, prev_y = vertexes[0]
@@ -735,7 +778,6 @@ class Canvas(Plotter):
         self.source.deleteBy(lambda r,rows=rows: r in rows)
         self.reload()
 
-
 Plotter.addCommand('v', 'visibility', 'options.disp_graph_labels = not options.disp_graph_labels', 'toggle disp_graph_labels option')
 
 Canvas.addCommand(None, 'go-left', 'if cursorBox: sheet.cursorBox.xmin -= cursorBox.w', 'move cursor left by its width')
@@ -768,7 +810,7 @@ Canvas.addCommand('zz', 'zoom-cursor', 'zoomTo(cursorBox)', 'set visible bounds
 
 Canvas.addCommand('-', 'zoomout-cursor', 'tmp=cursorBox.center; incrZoom(options.disp_zoom_incr); fixPoint(plotviewBox.center, tmp)', 'zoom out from cursor center')
 Canvas.addCommand('+', 'zoomin-cursor', 'tmp=cursorBox.center; incrZoom(1.0/options.disp_zoom_incr); fixPoint(plotviewBox.center, tmp)', 'zoom into cursor center')
-Canvas.addCommand('_', 'zoom-all', 'sheet.canvasBox = None; sheet.visibleBox = None; sheet.xzoomlevel=sheet.yzoomlevel=1.0; resetBounds(); refresh()', 'zoom to fit full extent')
+Canvas.addCommand('_', 'zoom-all', 'sheet.canvasBox = None; sheet.visibleBox = None; sheet.xzoomlevel=sheet.yzoomlevel=1.0; resetBounds()', 'zoom to fit full extent')
 Canvas.addCommand('z_', 'set-aspect', 'sheet.aspectRatio = float(input("aspect ratio=", value=aspectRatio)); refresh()', 'set aspect ratio')
 
 # set cursor box with left click