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

visidata/cmdlog.py

@@ -1,40 +1,47 @@
 import threading
 
-from visidata import *
+from visidata import vd, UNLOADED, namedlist, vlen, asyncthread, globalCommand, date
+from visidata import VisiData, BaseSheet, Sheet, ColumnAttr, VisiDataMetaSheet, JsonLinesSheet, TypedWrapper, AttrDict, Progress, ErrorSheet, CompleteKey, Path
 import visidata
 
 vd.option('replay_wait', 0.0, 'time to wait between replayed commands, in seconds', sheettype=None)
-vd.option('disp_replay_play', '▶', 'status indicator for active replay')
-vd.option('disp_replay_pause', '‖', 'status indicator for paused replay')
-vd.option('color_status_replay', 'green', 'color of replay status indicator')
-vd.option('replay_movement', False, 'insert movements during replay', sheettype=None)
+vd.theme_option('disp_replay_play', '▶', 'status indicator for active replay')
+vd.theme_option('color_status_replay', 'green', 'color of replay status indicator')
 
 # prefixes which should not be logged
 nonLogged = '''forget exec-longname undo redo quit
 show error errors statuses options threads jump
-replay cancel save-cmdlog macro cmdlog-sheet menu repeat
+replay cancel save-cmdlog macro cmdlog-sheet menu repeat reload-every
 go- search scroll prev next page start end zoom resize visibility sidebar
 mouse suspend redraw no-op help syscopy sysopen profile toggle'''.split()
 
 vd.option('rowkey_prefix', 'キ', 'string prefix for rowkey in the cmdlog', sheettype=None)
-vd.option('cmdlog_histfile', '', 'file to autorecord each cmdlog action to', sheettype=None)
 
 vd.activeCommand = UNLOADED
+vd._nextCommands = []  # list[str|CommandLogRow] for vd.queueCommand
+
+CommandLogRow = namedlist('CommandLogRow', 'sheet col row longname input keystrokes comment undofuncs'.split())
+
+@VisiData.api
+def queueCommand(vd, longname, input=None, sheet=None, col=None, row=None):
+    'Add command to queue of next commands to execute.'
+    vd._nextCommands.append(CommandLogRow(longname=longname, input=input, sheet=sheet, col=col, row=row))
+
 
 @VisiData.api
 def open_vd(vd, p):
-    return CommandLog(p.name, source=p, precious=True)
+    return CommandLog(p.base_stem, source=p, precious=True)
 
 @VisiData.api
 def open_vdj(vd, p):
-    return CommandLogJsonl(p.name, source=p, precious=True)
+    return CommandLogJsonl(p.base_stem, source=p, precious=True)
 
 VisiData.save_vd = VisiData.save_tsv
 
 
 @VisiData.api
 def save_vdj(vd, p, *vsheets):
-    with p.open_text(mode='w', encoding=vsheets[0].options.encoding) as fp:
+    with p.open(mode='w', encoding=vsheets[0].options.save_encoding) as fp:
         fp.write("#!vd -p\n")
         for vs in vsheets:
             vs.write_jsonl(fp)
@@ -46,7 +53,7 @@ def checkVersion(vd, desired_version):
         vd.fail("version %s required" % desired_version)
 
 @VisiData.api
-def fnSuffix(vd, prefix):
+def fnSuffix(vd, prefix:str):
     i = 0
     fn = prefix + '.vdj'
     while Path(fn).exists():
@@ -55,18 +62,6 @@ def fnSuffix(vd, prefix):
 
     return fn
 
-@BaseSheet.api
-def inputLongname(sheet):
-    longnames = set(k for (k, obj), v in vd.commands.iter(sheet))
-    return vd.input("command name: ", completer=CompleteKey(sorted(longnames)), type='longname')
-
-@BaseSheet.api
-def exec_longname(sheet, longname):
-    if not sheet.getCommand(longname):
-        vd.warning(f'no command {longname}')
-        return
-    sheet.execCommand(longname)
-
 def indexMatch(L, func):
     'returns the smallest i for which func(L[i]) is true'
     for i, x in enumerate(L):
@@ -74,7 +69,7 @@ def indexMatch(L, func):
             return i
 
 def keystr(k):
-    return  options.rowkey_prefix+','.join(map(str, k))
+    return  vd.options.rowkey_prefix+','.join(map(str, k))
 
 @VisiData.api
 def isLoggableCommand(vd, longname):
@@ -84,7 +79,7 @@ def isLoggableCommand(vd, longname):
     return True
 
 def isLoggableSheet(sheet):
-    return sheet is not vd.cmdlog and not isinstance(sheet, (OptionsSheet, ErrorSheet))
+    return sheet is not vd.cmdlog and not isinstance(sheet, (vd.OptionsSheet, ErrorSheet))
 
 
 @Sheet.api
@@ -94,13 +89,7 @@ def moveToRow(vs, rowstr):
     if rowidx is None:
         return False
 
-    if vs.options.replay_movement:
-        while vs.cursorRowIndex != rowidx:
-            vs.cursorRowIndex += 1 if (rowidx - vs.cursorRowIndex) > 0 else -1
-            while not vd.delay(0.5):
-                pass
-    else:
-        vs.cursorRowIndex = rowidx
+    vs.cursorRowIndex = rowidx
 
     return True
 
@@ -126,13 +115,7 @@ def moveToCol(vs, col):
     if vcolidx is None or vcolidx >= vs.nVisibleCols:
         return False
 
-    if vs.options.replay_movement:
-        while vs.cursorVisibleColIndex != vcolidx:
-            vs.cursorVisibleColIndex += 1 if (vcolidx - vs.cursorVisibleColIndex) > 0 else -1
-            while not vd.delay(0.5):
-                pass
-    else:
-        vs.cursorVisibleColIndex = vcolidx
+    vs.cursorVisibleColIndex = vcolidx
 
     return True
 
@@ -147,7 +130,10 @@ def commandCursor(sheet, execstr):
         rowname = keystr(k) if k else sheet.cursorRowIndex
 
     if contains(execstr, 'cursorTypedValue', 'cursorDisplay', 'cursorValue', 'cursorCell', 'cursorCol', 'cursorVisibleCol', 'ColumnAtCursor'):
-        colname = sheet.cursorCol.name or sheet.visibleCols.index(sheet.cursorCol)
+        if sheet.cursorCol:
+            colname = sheet.cursorCol.name or sheet.visibleCols.index(sheet.cursorCol)
+        else:
+            colname = None
     return colname, rowname
 
 
@@ -156,7 +142,7 @@ class CommandLogBase:
     'Log of commands for current session.'
     rowtype = 'logged commands'
     precious = False
-    _rowtype = namedlist('CommandLogRow', 'sheet col row longname input keystrokes comment undofuncs'.split())
+    _rowtype = CommandLogRow
     columns = [
         ColumnAttr('sheet'),
         ColumnAttr('col'),
@@ -185,7 +171,7 @@ class CommandLogBase:
 
             contains = lambda s, *substrs: any((a in s) for a in substrs)
             if contains(cmd.execstr, 'pasteFromClipboard'):
-                args = vd.sysclip_value().strip()
+                args = vd.sysclipValue().strip()
 
 
         comment = vd.currentReplayRow.comment if vd.currentReplayRow else cmd.helpstr
@@ -211,18 +197,10 @@ class CommandLogBase:
             return
 
         # remove user-aborted commands and simple movements (unless first command on the sheet, which created the sheet)
-        if not sheet.cmdlog.rows or vd.isLoggableCommand(vd.activeCommand.longname):
+        if not sheet.cmdlog_sheet.rows or vd.isLoggableCommand(vd.activeCommand.longname):
             if isLoggableSheet(sheet):      # don't record actions from cmdlog or other internal sheets on global cmdlog
                 self.addRow(vd.activeCommand)  # add to global cmdlog
             sheet.cmdlog_sheet.addRow(vd.activeCommand)  # add to sheet-specific cmdlog
-            if options.cmdlog_histfile:
-                name = date().strftime(options.cmdlog_histfile)
-                p = Path(name)
-                if not p.is_absolute():
-                    p = Path(options.visidata_dir)/f'{name}.jsonl'
-                if not getattr(vd, 'sessionlog', None):
-                    vd.sessionlog = vd.loadInternalSheet(CommandLog, p)
-                vd.sessionlog.append_tsv_row(vd.activeCommand)
 
         vd.activeCommand = None
 
@@ -256,50 +234,27 @@ class CommandLogJsonl(CommandLogBase, JsonLinesSheet):
 vd.paused = False
 vd.currentReplay = None     # CommandLog replaying currently
 vd.currentReplayRow = None  # must be global, to allow replay
-vd.semaphore = threading.Semaphore(0)
-
-
-@VisiData.api
-def replay_pause(vd):
-        if not vd.currentReplay:
-            vd.fail('no replay to pause')
-        else:
-            if vd.paused:
-                vd.replay_advance()
-            vd.paused = not vd.paused
-            vd.status('paused' if vd.paused else 'resumed')
-
-
-@VisiData.api
-def replay_advance(vd):
-        vd.currentReplay or vd.fail("no replay to advance")
-        vd.semaphore.release()
 
 
 @VisiData.api
 def replay_cancel(vd):
-        vd.currentReplay or vd.fail("no replay to cancel")
-        vd.currentReplayRow = None
-        vd.currentReplay = None
-        vd.semaphore.release()
+    vd.currentReplayRow = None
+    vd.currentReplay = None
+    vd._nextCommands.clear()
 
 
 @VisiData.api
 def moveToReplayContext(vd, r, vs):
         'set the sheet/row/col to the values in the replay row'
+        vs.ensureLoaded()
+        vd.sync()
         vd.clearCaches()
+
         if r.row not in [None, '']:
-            vs.moveToRow(r.row) or vd.error(f'no {r.row} row on {vs}')
+            vs.moveToRow(r.row) or vd.error(f'no "{r.row}" row on {vs}')
 
         if r.col not in [None, '']:
-            vs.moveToCol(r.col) or vd.error(f'no {r.col} column on {vs}')
-
-
-@VisiData.api
-def delay(vd, factor=1):
-        'returns True if delay satisfied'
-        acquired = vd.semaphore.acquire(timeout=options.replay_wait*factor if not vd.paused else None)
-        return acquired or not vd.paused
+            vs.moveToCol(r.col) or vd.error(f'no "{r.col}" column on {vs}')
 
 
 @VisiData.api
@@ -330,18 +285,21 @@ def replayOne(vd, r):
         else:
             vs = vs or vd.activeSheet
             if vs:
-                vd.push(vs)
+                if vs in vd.sheets:  # if already on sheet stack, push to top
+                    vd.push(vs)
             else:
                 vs = vd.cmdlog
 
-            vd.moveToReplayContext(r, vs)
-
-            if r.comment:
-                vd.status(r.comment)
+            try:
+                vd.moveToReplayContext(r, vs)
+                if r.comment:
+                    vd.status(r.comment)
 
-            vd.keystrokes = r.keystrokes
-            # <=v1.2 used keystrokes in longname column; getCommand fetches both
-            escaped = vs.execCommand(longname if longname else r.keystrokes, keystrokes=r.keystrokes)
+                # <=v1.2 used keystrokes in longname column; getCommand fetches both
+                escaped = vs.execCommand(longname if longname else r.keystrokes, keystrokes=r.keystrokes)
+            except Exception as e:
+                vd.exceptionCaught(e)
+                escaped = True
 
         vd.currentReplayRow = None
 
@@ -351,10 +309,21 @@ def replayOne(vd, r):
 
 
 @VisiData.api
-def replay_sync(vd, cmdlog, live=False):
-        'Replay all commands in log.'
+class DisableAsync:
+    def __enter__(self):
+        vd.execAsync = vd.execSync
+
+    def __exit__(self, exc_type, exc_val, tb):
+        vd.execAsync = lambda *args, vd=vd, **kwargs: visidata.VisiData.execAsync(vd, *args, **kwargs)
+
+
+@VisiData.api
+def replay_sync(vd, cmdlog):
+    'Replay all commands in *cmdlog*.'
+    with vd.DisableAsync():
         cmdlog.cursorRowIndex = 0
         vd.currentReplay = cmdlog
+
         with Progress(total=len(cmdlog.rows)) as prog:
             while cmdlog.cursorRowIndex < len(cmdlog.rows):
                 if vd.currentReplay is None:
@@ -377,22 +346,16 @@ def replay_sync(vd, cmdlog, live=False):
 
                 if vd.activeSheet:
                     vd.activeSheet.ensureLoaded()
-                vd.sync()
-                while not vd.delay():
-                    pass
 
         vd.status('replay complete')
         vd.currentReplay = None
 
 
 @VisiData.api
-@asyncthread
 def replay(vd, cmdlog):
-        'Inject commands into live execution with interface.'
-        for thread in vd.threads:
-            if thread.name == 'replay':
-                thread.noblock = True
-        vd.replay_sync(cmdlog, live=True)
+    'Inject commands into live execution with interface.'
+    vd.push(cmdlog)
+    vd._nextCommands.extend(cmdlog.rows)
 
 
 @VisiData.api
@@ -414,8 +377,9 @@ def setLastArgs(vd, args):
 
 @VisiData.property
 def replayStatus(vd):
-        x = options.disp_replay_pause if vd.paused else options.disp_replay_play
-        return ' │ %s %s/%s' % (x, vd.currentReplay.cursorRowIndex, len(vd.currentReplay.rows))
+    if vd._nextCommands:
+        return f' | [:status_replay] {len(vd._nextCommands)} {vd.options.disp_replay_play}[:]'
+    return ''
 
 
 @BaseSheet.property
@@ -428,7 +392,14 @@ def cmdlog(sheet):
 
 @BaseSheet.lazy_property
 def cmdlog_sheet(sheet):
-    return CommandLogJsonl(sheet.name+'_cmdlog', source=sheet, rows=[])
+    c = CommandLogJsonl(sheet.name+'_cmdlog', source=sheet, rows=[])
+    # copy over all existing globally set options
+    # you only need to do this for the first BaseSheet in a tree
+    if not isinstance(sheet.source, BaseSheet):
+        for r in vd.cmdlog.rows:
+            if r.sheet == 'global' and (r.longname == 'set-option') or (r.longname == 'unset-option'):
+                c.addRow(r)
+    return c
 
 
 @BaseSheet.property
@@ -452,7 +423,7 @@ def shortcut(self):
 def cmdlog(vd):
     if not vd._cmdlog:
         vd._cmdlog = CommandLogJsonl('cmdlog', rows=[])  # no reload
-        vd._cmdlog.reloadCols()
+        vd._cmdlog.resetCols()
         vd.beforeExecHooks.append(vd._cmdlog.beforeExecHook)
     return vd._cmdlog
 
@@ -489,27 +460,30 @@ BaseSheet.init('_shortcut')
 globalCommand('gD', 'cmdlog-all', 'vd.push(vd.cmdlog)', 'open global CommandLog for all commands executed in current session')
 globalCommand('D', 'cmdlog-sheet', 'vd.push(sheet.cmdlog)', "open current sheet's CommandLog with all other loose ends removed; includes commands from parent sheets")
 globalCommand('zD', 'cmdlog-sheet-only', 'vd.push(sheet.cmdlog_sheet)', 'open CommandLog for current sheet with commands from parent sheets removed')
-globalCommand('^D', 'save-cmdlog', 'saveSheets(inputPath("save cmdlog to: ", value=fnSuffix(name)), vd.cmdlog, confirm_overwrite=options.confirm_overwrite)', 'save CommandLog to filename.vd file')
-globalCommand('^U', 'replay-pause', 'vd.replay_pause()', 'pause/resume replay')
-globalCommand('^N', 'replay-advance', 'vd.replay_advance()', 'execute next row in replaying sheet')
-globalCommand('^K', 'replay-stop', 'vd.replay_cancel()', 'cancel current replay')
+BaseSheet.addCommand('^D', 'save-cmdlog', 'saveSheets(inputPath("save cmdlog to: ", value=fnSuffix(name)), vd.cmdlog)', 'save CommandLog to filename.vdj file')
+BaseSheet.bindkey('^N', 'no-op')
+BaseSheet.addCommand('^K', 'replay-stop', 'vd.replay_cancel(); vd.warning("replay canceled")', 'cancel current replay')
 
 globalCommand(None, 'show-status', 'status(input("status: "))', 'show given message on status line')
 globalCommand('^V', 'show-version', 'status(__version_info__);', 'Show version and copyright information on status line')
 globalCommand('z^V', 'check-version', 'checkVersion(input("require version: ", value=__version_info__))', 'check VisiData version against given version')
 
-globalCommand(' ', 'exec-longname', 'exec_longname(inputLongname())', 'execute command by its longname')
-
 CommandLog.addCommand('x', 'replay-row', 'vd.replayOne(cursorRow); status("replayed one row")', 'replay command in current row')
 CommandLog.addCommand('gx', 'replay-all', 'vd.replay(sheet)', 'replay contents of entire CommandLog')
-CommandLog.addCommand('^C', 'replay-stop', 'sheet.cursorRowIndex = sheet.nRows', 'abort replay')
 
 CommandLogJsonl.addCommand('x', 'replay-row', 'vd.replayOne(cursorRow); status("replayed one row")', 'replay command in current row')
 CommandLogJsonl.addCommand('gx', 'replay-all', 'vd.replay(sheet)', 'replay contents of entire CommandLog')
-CommandLogJsonl.addCommand('^C', 'replay-stop', 'sheet.cursorRowIndex = sheet.nRows', 'abort replay')
 
 CommandLog.options.json_sort_keys = False
 CommandLog.options.encoding = 'utf-8'
 CommandLogJsonl.options.json_sort_keys = False
 
-vd.addGlobals({"CommandLogBase": CommandLogBase})
+vd.addGlobals(CommandLogBase=CommandLogBase, CommandLogRow=CommandLogRow)
+
+vd.addMenuItems('''
+            View > Command log > this sheet > cmdlog-sheet
+    View > Command log > this sheet only > cmdlog-sheet-only
+    View > Command log > all commands > cmdlog-all
+    System > Execute longname > exec-longname
+    Help > Version > show-version
+''')

visidata/color.py

@@ -1,45 +1,83 @@
 import curses
 import functools
 from copy import copy
+from collections import namedtuple
+from dataclasses import dataclass
 
-from visidata import options, Extensible, drawcache, drawcache_property, VisiData
+from visidata import vd, options, Extensible, drawcache, drawcache_property, VisiData
 import visidata
-from collections import namedtuple
 
-__all__ = ['ColorAttr', 'colors', 'update_attr', 'ColorMaker']
+__all__ = ['ColorAttr', 'colors', 'update_attr', 'ColorMaker', 'rgb_to_attr']
 
+vd.help_color = '''Color syntax: `<attribute> <fg-color> on <bg-color>`
 
-ColorAttr = namedtuple('ColorAttr', ('color', 'attributes', 'precedence', 'attr'))
+- attributes: [:bold]bold[/] [:underline]underline[/] [:italic]italic[/] [:reverse]reverse[/]
+- colors: 0-255 or [:black on 238]black[/] [:red on 238]red[/] [:green on 238]green[/] [:yellow on 238]yellow[/] [:blue on 238]blue[/] [:magenta on 238]magenta[/] [:cyan on 238]cyan[/] [:white on 238]white[/]
+- the second color is used as a fallback if the first color is not available
 
+See [:onclick https://visidata.org/docs/colors]https://visidata.org/docs/colors[/] for more detailed info.
+'''
 
-def update_attr(oldattr, updattr, updprec=None):
-    if isinstance(updattr, ColorAttr):
-        if updprec is None:
-            updprec = updattr.precedence
-        updcolor = updattr.color
-        updattr = updattr.attributes
-    else:
-        updcolor = updattr & curses.A_COLOR
-        updattr = updattr & ~curses.A_COLOR
-        if updprec is None:
-            updprec = 0
+
+@dataclass
+class ColorAttr:
+    fg:int = -1         # default is no foreground specified
+    bg:int = -1         # default is no background specified
+    attributes:int = 0       # default is no attributes
+    precedence:int = 0  # default is lowest priority
+    colorname:str = ''
+
+    def __init__(self, fg:int=-1, bg:int=-1, attributes:int=0, precedence:int=0, colorname:str=''):
+        assert fg < 256, fg
+        assert bg < 256, bg
+        self.fg = fg
+        self.bg = bg
+        self.attributes = attributes
+        self.precedence = precedence
+        self.colorname = colorname
+
+    def update(self, b:'ColorAttr', prec:int=10) -> 'ColorAttr':
+        return update_attr(self, b, prec)
+
+    @property
+    def attr(self) -> int:
+        a = colors._get_colorpair(self.fg, self.bg, self.colorname) | self.attributes
+        assert a >= 0, a
+        return a
+
+    def as_str(self) -> str:
+        attrnames = [attrname for attrname, attr in colors._attrs.items() if self.attributes & attr]
+        attrnames.append(f'{self.fg} on {self.bg}')
+        return ' '.join(attrnames)
+
+
+def update_attr(oldattr:ColorAttr, updattr:ColorAttr, updprec:int=None) -> ColorAttr:
+    assert isinstance(updattr, ColorAttr), updattr
+    if updprec is None:
+        updprec = updattr.precedence
+    updfg = updattr.fg
+    updbg = updattr.bg
+    updattr = updattr.attributes
 
     # starting values, work backwards
-    newcolor = oldattr.color
+    newfg = oldattr.fg
+    newbg = oldattr.bg
     newattr = oldattr.attributes | updattr
     newprec = oldattr.precedence
 
-    if not newcolor or updprec > newprec:
-        if updcolor:
-            newcolor = updcolor
-        newprec = updprec
+    if newfg < 0 or (updfg >= 0 and updprec > newprec):
+        newfg = updfg
+    if newbg < 0 or (updbg >= 0 and updprec > newprec):
+        newbg = updbg
 
-    return ColorAttr(newcolor, newattr, newprec, newcolor | newattr)
+    newprec = max(updprec, newprec)
+
+    return ColorAttr(newfg, newbg, newattr, newprec)
 
 
 class ColorMaker:
     def __init__(self):
-        self.color_pairs = {}  # (fg,bg) -> (color_attr, colornamestr) (can be or'ed with other attrs)
+        self.color_pairs = {}  # (fg,bg) -> (pairnum, colornamestr) (pairnum can be or'ed with other attrs)
         self.color_cache = {}  # colorname -> colorpair
 
     @drawcache_property
@@ -47,30 +85,44 @@ class ColorMaker:
         return {}
 
     def setup(self):
-        curses.use_default_colors()
+        try:
+            curses.use_default_colors()
+        except Exception as e:
+            pass
 
     @drawcache_property
     def colors(self):
         'not computed until curses color has been initialized'
         return {x[6:]:getattr(curses, x) for x in dir(curses) if x.startswith('COLOR_') and x != 'COLOR_PAIRS'}
 
-    def __getitem__(self, colornamestr):
-        return self._colornames_to_cattr(colornamestr).attr
+    def __getitem__(self, colorname:str) -> ColorAttr:
+        'colors["green"] or colors["foo"] returns parsed ColorAttr.'
+        return self.get_color(colorname)
 
-    def __getattr__(self, optname):
-        'colors.color_foo returns colors[options.color_foo]'
-        return self.get_color(optname).attr
+    def __getattr__(self, optname) -> ColorAttr:
+        'colors.color_foo or colors.foo returns parsed ColorAttr.'
+        return self.get_color(optname)
 
     @drawcache
     def resolve_colors(self, colorstack):
         'Returns the ColorAttr for the colorstack, a list of (prec, color_option_name) sorted highest-precedence color first.'
-        cattr = ColorAttr(0,0,0,0)
+        cattr = ColorAttr()
         for prec, coloropt in colorstack:
             c = self.get_color(coloropt)
             cattr = update_attr(cattr, c, prec)
         return cattr
 
-    def split_colorstr(self, colorstr):
+    def get_color(self, optname:str, precedence:int=0) -> ColorAttr:
+        '''Return ColorAttr for options.color_foo if *optname* of either "foo" or "color_foo",
+           Otherwise parse *optname* for colorstring like "bold 34 red on 135 blue".'''
+        r = self.colorcache.get(optname, None)
+        if r is None:
+            coloropt = vd.options._get(optname) or vd.options._get(f'color_{optname}')
+            colornamestr = coloropt.value if coloropt else optname
+            r = self.colorcache[optname] = self._colornames_to_cattr(colornamestr, precedence)
+        return r
+
+    def _split_colorstr(self, colorstr):
         'Return (fgstr, bgstr, attrlist) parsed from colorstr.'
         fgbgattrs = ['', '', []]  # fgstr, bgstr, attrlist
         if not colorstr:
@@ -92,12 +144,19 @@ class ColorMaker:
                 if not fgbgattrs[i]:  # keep first known color
                     if self._get_colornum(x) is not None:   # only set known colors
                         fgbgattrs[i] = x
+                    else:
+                        fgbgattrs[i] = None
 
         return fgbgattrs
 
-    def _get_colornum(self, colorname, default=-1):
+    def _get_colornum(self, colorname:'str|int', default:int=-1) -> int:
         'Return terminal color number for colorname.'
-        if not colorname: return default
+        if isinstance(colorname, int):
+            return colorname
+
+        if not colorname:
+            return default
+
         r = self.color_cache.get(colorname, None)
         if r is not None:
             return r
@@ -119,41 +178,68 @@ class ColorMaker:
         except ValueError:  # Python 3.10+  issue #1227
             return None
 
-    @drawcache
-    def _colornames_to_cattr(self, colornamestr, precedence=0):
-        fg, bg, attrlist = self.split_colorstr(colornamestr)
+    def _attrnames_to_num(self, attrnames:'list[str]') -> int:
         attrs = 0
-        for attr in attrlist:
+        for attr in attrnames:
             attrs |= getattr(curses, 'A_'+attr.upper())
+        return attrs
 
-        if not fg and not bg:
-            color = 0
-        else:
-            deffg, defbg, _ = self.split_colorstr(options.color_default)
-            fgbg = (self._get_colornum(fg, self._get_colornum(deffg)),
-                    self._get_colornum(bg, self._get_colornum(defbg)))
-            pairnum, _ = self.color_pairs.get(fgbg, (None, ''))
+    @drawcache_property
+    def _attrs(self):
+        return {k[2:].lower():getattr(curses, k) for k in dir(curses) if k.startswith('A_') and k != 'A_ATTRIBUTES'}
+
+    @drawcache
+    def _colornames_to_cattr(self, colorname:str, precedence=0) -> ColorAttr:
+        fg, bg, attrlist = self._split_colorstr(colorname)
+
+        fg = self._get_colornum(fg)
+        bg = self._get_colornum(bg)
+        return ColorAttr(fg, bg,
+                         self._attrnames_to_num(attrlist),
+                         precedence, colorname)
+
+    def _get_colorpair(self, fg:'int|None', bg:'int|None', colorname:str) -> int:
+            pairnum, _ = self.color_pairs.get((fg, bg), (None, ''))
             if pairnum is None:
                 if len(self.color_pairs) > 254:
                     self.color_pairs.clear()  # start over
                     self.color_cache.clear()
                 pairnum = len(self.color_pairs)+1
+                if fg is None: fg = -1
+                if bg is None: bg = -1
                 try:
-                    curses.init_pair(pairnum, *fgbg)
+                    curses.init_pair(pairnum, fg, bg)
                 except curses.error as e:
-                    return ColorAttr(0, attrs, precedence, attrs)
-                self.color_pairs[fgbg] = (pairnum, colornamestr)
+                    return 0  # do not cache
+                self.color_pairs[(fg, bg)] = (pairnum, colorname)
 
-            color = curses.color_pair(pairnum)
-        return ColorAttr(color, attrs, precedence, color | attrs)
+            return curses.color_pair(pairnum)
 
-    def get_color(self, optname, precedence=0):
-        'colors.color_foo returns colors[options.color_foo]'
-        r = self.colorcache.get(optname, None)
-        if r is None:
-            coloropt = options._get(optname)
-            colornamestr = coloropt.value if coloropt else optname
-            r = self.colorcache[optname] = self._colornames_to_cattr(colornamestr, precedence)
-        return r
 
 colors = ColorMaker()
+
+def rgb_to_xterm256(r:int,g:int,b:int,a:int=255) -> int:
+    if a == 0:
+        return -1
+
+    if max(r,g,b) - min(r,g,b) < 8:
+        if r <= 4: return 16
+        elif r <= 8: return 232
+        elif r >= 247: return 231
+        elif r >= 238: return 255
+        else:
+            return int(232 + (r-8)//10)
+    else:
+        r = max(0, r-(95-40)) // 40
+        g = max(0, g-(95-40)) // 40
+        b = max(0, b-(95-40)) // 40
+        return int(16 + r*36 + g*6 + b)
+
+
+@functools.lru_cache(256)
+def rgb_to_attr(r:int,g:int,b:int,a:int=255) -> str:
+    return str(rgb_to_xterm256(r,g,b,a))
+
+
+import sys
+vd.addGlobals({k:getattr(sys.modules[__name__], k) for k in __all__})