SYMBOL INDEX (2918 symbols across 244 files)

FILE: bin/viewtsv.py
  function open_tsv (line 9) | def open_tsv(vd, p):
  class MinimalTsvSheet (line 13) | class MinimalTsvSheet(Sheet):
    method reload (line 17) | def reload(self):

FILE: dev/visidata-brew.rb
  class Visidata (line 1) | class Visidata < Formula
    method install (line 65) | def install

FILE: dev/zsh-completion.py
  function generate_completion (line 18) | def generate_completion(opt):

FILE: plugins/geocoding.py
  function geocode (line 18) | def geocode(addr):
  function geocode_col (line 26) | def geocode_col(sheet, vcolidx):

FILE: plugins/vtask.py
  function editTask (line 11) | def editTask(task):
  class TodoSheet (line 39) | class TodoSheet(Sheet):
    method newRow (line 66) | def newRow(self, **kwargs):
    method reload (line 69) | def reload(self):
  function isChanged (line 74) | def isChanged(r, key):
  class TaskAnnotationsSheet (line 78) | class TaskAnnotationsSheet(Sheet):
    method reload (line 84) | def reload(self):
  function main_vtask (line 101) | def main_vtask():

FILE: setup.py
  function all_requirements (line 9) | def all_requirements():

FILE: snippets/gender.py
  function gg_detect (line 15) | def gg_detect():
  function gender (line 19) | def gender(first_name):

FILE: snippets/geolocate.py
  function geolocate (line 9) | def geolocate(ip):

FILE: snippets/rank.py
  class RankColumn (line 11) | class RankColumn(Column):
    method __init__ (line 12) | def __init__(self, col, **kwargs):
    method calcValue (line 18) | def calcValue(self, row):
    method resetCache (line 22) | def resetCache(self):

FILE: visidata/__init__.py
  class EscapeException (line 10) | class EscapeException(BaseException):
  function addGlobals (line 15) | def addGlobals(*args, **kwargs):
  function getGlobals (line 25) | def getGlobals():
  function importFeatures (line 138) | def importFeatures():

FILE: visidata/_input.py
  class AcceptInput (line 19) | class AcceptInput(Exception):
  function injectInput (line 27) | def injectInput(vd, x):
  function getCommandInput (line 34) | def getCommandInput(vd):
  function execCommand (line 44) | def execCommand(sheet, longname, *args, **kwargs):
  function acceptThenFunc (line 50) | def acceptThenFunc(*longnames):
  class EnableCursor (line 59) | class EnableCursor:
    method __enter__ (line 60) | def __enter__(self):
    method __exit__ (line 65) | def __exit__(self, exc_type, exc_val, tb):
  function until_get_wch (line 71) | def until_get_wch(scr):
  function splice (line 85) | def splice(v:str, i:int, s:str):
  function drawInputHelp (line 91) | def drawInputHelp(vd, scr):
  function clean_printable (line 102) | def clean_printable(s):
  function delchar (line 107) | def delchar(s, i, remove=1):
  function find_word (line 111) | def find_word(s, a, b, incr):
  class InputWidget (line 130) | class InputWidget:
    method __init__ (line 131) | def __init__(self,
    method editline (line 173) | def editline(self, scr, y, x, w, attr=ColorAttr(), updater=lambda val:...
    method draw (line 191) | def draw(self, scr, y, x, w, attr=ColorAttr(), clear=True):
    method handle_key (line 247) | def handle_key(self, ch:str, scr) -> bool:
    method completion (line 318) | def completion(self, v, i, state_incr):
    method reset_completion (line 337) | def reset_completion(self):
    method prev_history (line 344) | def prev_history(self, v, i):
    method next_history (line 354) | def next_history(self, v, i):
  function editText (line 368) | def editText(vd, y, x, w, attr=ColorAttr(), value='',
  function inputsingle (line 415) | def inputsingle(vd, prompt, record=True):
  function inputMultiple (line 441) | def inputMultiple(vd, updater=lambda val: None, record=True, **kwargs):
  function input (line 539) | def input(vd, prompt, type=None, defaultLast=False, history=[], dy=0, at...
  function confirm (line 609) | def confirm(vd, prompt, exc=EscapeException):
  class CompleteKey (line 624) | class CompleteKey:
    method __init__ (line 625) | def __init__(self, items):
    method __call__ (line 628) | def __call__(self, val, state):
  function editCell (line 634) | def editCell(self, vcolidx=None, rowidx=None, value=None, **kwargs):

FILE: visidata/_open.py
  function inputFilename (line 12) | def inputFilename(vd, prompt, *args, **kwargs):
  function inputPath (line 23) | def inputPath(vd, *args, **kwargs):
  function _completeFilename (line 27) | def _completeFilename(val, state):
  function guessFiletype (line 49) | def guessFiletype(vd, p, *args, funcprefix='guess_'):
  function guess_extension (line 72) | def guess_extension(vd, path):
  function openPath (line 81) | def openPath(vd, p, filetype=None, create=False):
  function openSource (line 149) | def openSource(vd, p, filetype=None, create=False, **kwargs):
  function open_txt (line 180) | def open_txt(vd, p):

FILE: visidata/_types.py
  function anytype (line 34) | def anytype(r=None):
  function numericFormatter (line 41) | def numericFormatter(vd, fmtstr, typedval):
  function numericType (line 53) | def numericType(vd, icon='', fmtstr='', formatter=vd.numericFormatter):
  class VisiDataType (line 62) | class VisiDataType:
    method __init__ (line 64) | def __init__(self, typetype=None, icon=None, fmtstr='', formatter=vd.n...
  function addType (line 73) | def addType(vd, typetype=None, icon=None, fmtstr='', formatter=vd.numeri...
  function getType (line 95) | def getType(vd, typetype):
  function numtype (line 100) | def numtype(r=None):
  function isNumeric (line 116) | def isNumeric(vd, col):
  function deduceType (line 119) | def deduceType(v):
  function floatlocale (line 127) | def floatlocale(*args):
  class vlen (line 136) | class vlen(int):
    method __new__ (line 137) | def __new__(cls, v=0):
    method __len__ (line 143) | def __len__(self):

FILE: visidata/_urlcache.py
  function urlcache (line 9) | def urlcache(vd, url, days=1, text=True, headers={}):
  function enable_requests_cache (line 40) | def enable_requests_cache(vd):

FILE: visidata/aggregators.py
  function getValueRows (line 30) | def getValueRows(self, rows):
  function getValues (line 44) | def getValues(self, rows):
  function aggregators_get (line 56) | def aggregators_get(col):
  function aggregators_set (line 65) | def aggregators_set(col, aggs):
  class Aggregator (line 82) | class Aggregator:
    method __init__ (line 83) | def __init__(self, name, type, funcValues=None, helpstr=''):
    method aggregate (line 90) | def aggregate(self, col, rows):  # wrap builtins so they can have a .type
  class ListAggregator (line 100) | class ListAggregator(Aggregator):
    method __init__ (line 106) | def __init__(self, name, type, helpstr='', listtype=None):
    method aggregate (line 112) | def aggregate(self, col, rows) -> list:
    method aggregate_list (line 120) | def aggregate_list(self, col, row_group) -> list:
  function aggregator (line 130) | def aggregator(vd, name, funcValues, helpstr='', *, type=None):
  function aggregator_list (line 137) | def aggregator_list(vd, name, helpstr='', type=anytype, listtype=anytype):
  function mean (line 147) | def mean(vals):
  function vsum (line 153) | def vsum(vals):
  function stdev (line 157) | def stdev(vals):
  function _percentile (line 169) | def _percentile(N, percent, key=lambda x:x):
  class PercentileAggregator (line 192) | class PercentileAggregator(Aggregator):
    method __init__ (line 193) | def __init__(self, pct, helpstr=''):
    method aggregate (line 197) | def aggregate(self, col, rows):
  function quantiles (line 201) | def quantiles(q, helpstr):
  function aggregate_groups (line 205) | def aggregate_groups(sheet, col, rows, aggr) -> list:
  class KeyFindingAggregator (line 269) | class KeyFindingAggregator(Aggregator):
    method __init__ (line 277) | def __init__(self, aggr_func, *args, **kwargs):
    method aggregate (line 281) | def aggregate(self, col, rows):
  function addAggregators (line 303) | def addAggregators(sheet, cols, aggrnames):
  function aggname (line 316) | def aggname(col, agg):
  function aggregateTotal (line 322) | def aggregateTotal(col, agg):
  function _aggregateTotalAsync (line 331) | def _aggregateTotalAsync(col, agg):
  function memo_aggregate (line 337) | def memo_aggregate(col, agg_choices, rows):
  function aggregator_choices (line 354) | def aggregator_choices(vd):
  function chooseAggregators (line 363) | def chooseAggregators(vd, prompt = 'choose aggregators: '):
  function addcol_aggregate (line 394) | def addcol_aggregate(sheet, col, aggrnames):

FILE: visidata/apps/galcon/galcon-server.py
  function error (line 18) | def error(s):
  class OptionsObject (line 22) | class OptionsObject:
    method __init__ (line 24) | def __init__(self, d):
    method __getattr__ (line 26) | def __getattr__(self, k):
    method __setitem__ (line 28) | def __setitem__(self, k, v):
  class Game (line 33) | class Game:
    method __init__ (line 34) | def __init__(self):
    method generate_planets (line 53) | def generate_planets(self):
    method notify (line 75) | def notify(self, eventstr):
    method start_game (line 78) | def start_game(self):
    method end_turn (line 81) | def end_turn(self):
    method next_turn (line 164) | def next_turn(self):
    method GET_scores (line 177) | def GET_scores(self, pl, **kwargs):
    method GET_player_quit (line 193) | def GET_player_quit(self, pl, **kwargs):
    method started (line 207) | def started(self):
    method POST_options (line 210) | def POST_options(self, pl, **kwargs):
    method GET_options (line 219) | def GET_options(self, pl, **kwargs):
    method GET_set_option (line 222) | def GET_set_option(self, pl, option='', value=''):
    method GET_regen_map (line 231) | def GET_regen_map(self, pl, **kwargs):
    method GET_gamestate (line 237) | def GET_gamestate(self, pl, **kwargs):
    method POST_auth (line 247) | def POST_auth(self, pl, **kwargs):
    method GET_join (line 250) | def GET_join(self, pl, **kwargs):
    method GET_ready (line 263) | def GET_ready(self, pl, **kwargs):
    method GET_players (line 277) | def GET_players(self, pl, **kwargs):
    method GET_planets (line 280) | def GET_planets(self, pl, **kwargs):
    method GET_deployments (line 283) | def GET_deployments(self, pl, **kwargs):
    method GET_events (line 286) | def GET_events(self, pl):
    method predeploy (line 289) | def predeploy(self, launch_player, launch_planet_name=None, dest_plane...
    method GET_deploy (line 310) | def GET_deploy(self, launch_player, launch_planet_name=None, dest_plan...
    method GET_validate_deploy (line 327) | def GET_validate_deploy(self, launch_player, launch_planet_name=None, ...
    method GET_end_turn (line 332) | def GET_end_turn(self, pl):
    method distance (line 343) | def distance(self, here, dest):
  class Player (line 351) | class Player:
    method __init__ (line 352) | def __init__(self, name, md5_password, sessionid):
    method as_dict (line 359) | def as_dict(self):
    method __str__ (line 365) | def __str__(self):
  class Planet (line 369) | class Planet:
    method __init__ (line 370) | def __init__(self, name, x, y, prod=0, killpct=0, owner=None):
    method xy (line 380) | def xy(self):
    method __str__ (line 383) | def __str__(self):
    method as_dict (line 386) | def as_dict(self):
  class Deployment (line 405) | class Deployment:
    method __init__ (line 406) | def __init__(self, launch_player, launch_turn, launch_planet, dest_pla...
    method as_dict (line 416) | def as_dict(self):
  class Event (line 429) | class Event:
    method __init__ (line 430) | def __init__(self, turn_num, eventstr):
    method as_dict (line 434) | def as_dict(self):
  class HTTPException (line 443) | class HTTPException(Exception):
    method __init__ (line 444) | def __init__(self, errcode, text):
  class WSIServer (line 449) | class WSIServer(http.server.HTTPServer):
    method __init__ (line 450) | def __init__(self, *args, **kwargs):
  class WSIHandler (line 457) | class WSIHandler(http.server.BaseHTTPRequestHandler):
    method generic_handler (line 458) | def generic_handler(self, reqtype, path, data):
    method do_GET (line 516) | def do_GET(self):
    method do_POST (line 520) | def do_POST(self):
  function generate_map_random (line 526) | def generate_map_random(width, height, num_planets, distancefunc):
  function generate_map_rclogo_fixed (line 542) | def generate_map_rclogo_fixed(width, height, num_planets, distancefunc):
  function generate_map_rclogo_var (line 583) | def generate_map_rclogo_var(width, height, num_planets, distancefunc):
  function main (line 649) | def main():

FILE: visidata/apps/galcon/galcon.py
  function openhttp_galcon (line 30) | def openhttp_galcon(vd, p):
  class GalconSheet (line 39) | class GalconSheet(Sheet):
  class WSIClient (line 55) | class WSIClient:
    method __init__ (line 56) | def __init__(self, url):
    method submit_turn (line 72) | def submit_turn(self):
    method current_turn (line 89) | def current_turn(self):
    method rightStatus (line 96) | def rightStatus(self, sheet):
    method login (line 116) | def login(self):  # before curses init
    method get (line 134) | def get(self, path, **kwargs):
    method player_quit (line 147) | def player_quit(self):
    method add_deployment (line 154) | def add_deployment(self, sources, dest, nships):
    method refresh_everything (line 169) | def refresh_everything(self):
  class PlayersSheet (line 197) | class PlayersSheet(GalconSheet):
    method loader (line 206) | def loader(self):
    method get_player_color (line 213) | def get_player_color(self, playername):
  function distance_turns (line 220) | def distance_turns(pl1, pl2):
  class PlanetsSheet (line 225) | class PlanetsSheet(GalconSheet):
    method reload (line 243) | def reload(self):
  class QueuedDeploymentsSheet (line 256) | class QueuedDeploymentsSheet(GalconSheet):
    method colorIncomplete (line 270) | def colorIncomplete(self, col, row, value):
    method reload (line 275) | def reload(self):
  class HistoricalDeploymentsSheet (line 279) | class HistoricalDeploymentsSheet(GalconSheet):
    method reload (line 294) | def reload(self):
  class EventsSheet (line 300) | class EventsSheet(GalconSheet):
    method reload (line 307) | def reload(self):
  function CellColor (line 319) | def CellColor(prec, color, func):
  class MapSheet (line 323) | class MapSheet(GalconSheet):
    method title (line 333) | def title(self):
    method title (line 337) | def title(self, value):
    method colorSpace (line 341) | def colorSpace(sheet,col,row,value):
    method cycle_info (line 349) | def cycle_info(self):
    method reload (line 353) | def reload(self):
  class GameOptionsSheet (line 386) | class GameOptionsSheet(GalconSheet):
    method reload (line 392) | def reload(self):

FILE: visidata/apps/vdsql/__main__.py
  function main (line 3) | def main():

FILE: visidata/apps/vdsql/_ibis.py
  function vdtype_to_ibis_type (line 16) | def vdtype_to_ibis_type(t):
  function dtype_to_vdtype (line 26) | def dtype_to_vdtype(dtype):
  function configure_ibis (line 48) | def configure_ibis(vd):
  function open_vdsql (line 63) | def open_vdsql(vd, p, filetype=None):
  class IbisConnectionPool (line 81) | class IbisConnectionPool:
    method __init__ (line 82) | def __init__(self, source, pool=None, total=0):
    method __copy__ (line 87) | def __copy__(self):
    method get_conn (line 91) | def get_conn(self):
  class IbisTableIndexSheet (line 98) | class IbisTableIndexSheet(IndexSheet):
    method con (line 102) | def con(self):
    method rawSql (line 105) | def rawSql(self, qstr):
    method iterload (line 113) | def iterload(self):
  class IbisColumn (line 143) | class IbisColumn(ItemColumn):
    method ibis_type (line 145) | def ibis_type(self):
    method memo_aggregate (line 149) | def memo_aggregate(self, agg, rows):
    method expand (line 164) | def expand(self, rows):
    method expand_struct (line 167) | def expand_struct(self, rows):
  class LazyIbisColMap (line 185) | class LazyIbisColMap:
    method __init__ (line 186) | def __init__(self, sheet, q):
    method __getitem__ (line 191) | def __getitem__(self, k):
  class IbisTableSheet (line 196) | class IbisTableSheet(Sheet):
    method con (line 198) | def con(self):
    method help_sidebars (line 202) | def help_sidebars(self):
    method choose_sidebar (line 235) | def choose_sidebar(self):
    method curcol_sql (line 248) | def curcol_sql(self):
    method ibis_expr_to_sql (line 253) | def ibis_expr_to_sql(self, expr, fragment=False):
    method sidebar (line 259) | def sidebar(self) -> str:
    method ibis_locals (line 267) | def ibis_locals(self):
    method select_row (line 270) | def select_row(self, row):
    method stoggle_row (line 275) | def stoggle_row(self, row):
    method unselect_row (line 278) | def unselect_row(self, row):
    method matchRowKeyExpr (line 282) | def matchRowKeyExpr(self, row):
    method ibis_current_expr (line 292) | def ibis_current_expr(self):
    method str_current_expr (line 296) | def str_current_expr(self):
    method str_pending_expr (line 300) | def str_pending_expr(self):
    method get_current_expr (line 303) | def get_current_expr(self, typed=False):
    method ibis_filter (line 319) | def ibis_filter(self):
    method pending_expr (line 327) | def pending_expr(self):
    method ibisCompileExpr (line 344) | def ibisCompileExpr(self, expr, q):
    method evalIbisExpr (line 350) | def evalIbisExpr(self, expr):
    method base_sql (line 354) | def base_sql(self):
    method pending_sql (line 358) | def pending_sql(self):
    method sqlize (line 361) | def sqlize(self, expr):
    method substrait (line 367) | def substrait(self):
    method withRowcount (line 372) | def withRowcount(self, q):
    method beforeLoad (line 378) | def beforeLoad(self):
    method baseQuery (line 382) | def baseQuery(self, con):
    method fqtblname (line 388) | def fqtblname(self, con) -> str:
    method iterload (line 394) | def iterload(self):
    method reloadColumns (line 406) | def reloadColumns(self, expr, start=1):
    method countSelectedRows (line 425) | def countSelectedRows(self):
    method countRows (line 429) | def countRows(self):
    method groupBy (line 436) | def groupBy(self, groupByCols):
    method unfurl_col (line 473) | def unfurl_col(self, col):
    method openJoin (line 480) | def openJoin(self, others, jointype=''):
  function ibis_col (line 516) | def ibis_col(col):
  function get_ibis_col (line 521) | def get_ibis_col(col, query:'ibis.Expr', typed=False) -> 'ibis.Expr':
  function ibis_aggrs (line 555) | def ibis_aggrs(col):
  function ibis_aggr (line 560) | def ibis_aggr(col, aggname):
  function stoggle_rows (line 582) | def stoggle_rows(sheet):
  function clearSelected (line 588) | def clearSelected(sheet):
  function addUndoSelection (line 595) | def addUndoSelection(sheet):
  function select_equal_cell (line 601) | def select_equal_cell(sheet, col, typedval):
  function select_col_regex (line 614) | def select_col_regex(sheet, col, regex):
  function select_expr (line 620) | def select_expr(sheet, expr):
  function addcol_split (line 626) | def addcol_split(sheet, col, delim):
  function addcol_subst (line 638) | def addcol_subst(sheet, col, before='', after=''):
  function addcol_cast (line 648) | def addcol_cast(sheet, col):
  function notimpl (line 663) | def notimpl(sheet):
  function dup_selected (line 692) | def dup_selected(sheet):
  function incrementName (line 700) | def incrementName(sheet):
  function dup_limit (line 709) | def dup_limit(sheet, limit:int):
  function rawSql (line 717) | def rawSql(sheet, qstr):
  class IbisFreqTable (line 725) | class IbisFreqTable(IbisTableSheet):
    method freqExpr (line 726) | def freqExpr(self, row):
    method selectRow (line 733) | def selectRow(self, row):
    method openRow (line 738) | def openRow(self, row):
    method openRows (line 744) | def openRows(self, rows):

FILE: visidata/apps/vdsql/bigquery.py
  function openurl_bigquery (line 15) | def openurl_bigquery(vd, p, filetype=None):
  function configure_bigquery (line 24) | def configure_bigquery(vd):
  class BigqueryDatabaseIndexSheet (line 33) | class BigqueryDatabaseIndexSheet(Sheet):
    method con (line 45) | def con(self):
    method iterload (line 51) | def iterload(self):
    method openRow (line 54) | def openRow(self, row):

FILE: visidata/apps/vdsql/clickhouse.py
  function openurl_clickhouse (line 9) | def openurl_clickhouse(vd, p, filetype=None):
  class ClickhouseSheet (line 17) | class ClickhouseSheet(IbisTableSheet):
    method countRows (line 19) | def countRows(self):
    method iterload (line 24) | def iterload(self):

FILE: visidata/apps/vdsql/setup.py
  function readme (line 10) | def readme():
  function requirements (line 14) | def requirements():
  function requirements_extra (line 17) | def requirements_extra():

FILE: visidata/apps/vdsql/snowflake.py
  function openurl_snowflake (line 9) | def openurl_snowflake(vd, p, filetype=None):
  class SnowflakeSheet (line 15) | class SnowflakeSheet(IbisTableSheet):
    method countRows (line 17) | def countRows(self):
    method executeSql (line 23) | def executeSql(self, sql):
    method iterload (line 44) | def iterload(self):
    method cancelQuery (line 57) | def cancelQuery(self, qid):

FILE: visidata/apps/vgit/abort.py
  function abortWhatever (line 6) | def abortWhatever(sheet):

FILE: visidata/apps/vgit/blame.py
  function git_blame (line 7) | def git_blame(vd, gitpath, args, **kwargs):
  class FormatColumn (line 13) | class FormatColumn(Column):
    method calcValue (line 14) | def calcValue(self, row):
  class GitBlame (line 21) | class GitBlame(GitSheet):
    method iterload (line 38) | def iterload(self):

FILE: visidata/apps/vgit/branch.py
  function git_branch (line 12) | def git_branch(vd, p, args):
  function _remove_prefix (line 20) | def _remove_prefix(text, prefix):
  class GitBranchNameColumn (line 26) | class GitBranchNameColumn(WritableColumn):
    method calcValue (line 27) | def calcValue(self, row):
    method putValue (line 30) | def putValue(self, row, val):
  class GitBranch (line 34) | class GitBranch(GitSheet):
    method iterload (line 63) | def iterload(self):
    method commitAddRow (line 107) | def commitAddRow(self, row):
    method commitDeleteRow (line 110) | def commitDeleteRow(self, row):
  function gitBranchStatuses (line 115) | def gitBranchStatuses(sheet):

FILE: visidata/apps/vgit/config.py
  function git_config (line 11) | def git_config(vd, p, args):
  function batched (line 17) | def batched(iterable, n=1):
  class GitConfigColumn (line 26) | class GitConfigColumn(Column):
    method calcValue (line 27) | def calcValue(self, row):
    method putValue (line 30) | def putValue(self, row, val):
  class GitConfig (line 39) | class GitConfig(GitSheet):
    method iterload (line 54) | def iterload(self):
    method commitDeleteRow (line 79) | def commitDeleteRow(self, row):
    method commitAddRow (line 84) | def commitAddRow(self, row):

FILE: visidata/apps/vgit/diff.py
  function git_diff (line 11) | def git_diff(vd, p, args):
  function _parseStartCount (line 14) | def _parseStartCount(s):
  class GitDiffSheet (line 22) | class GitDiffSheet(GitSheet):
    method hunkCount (line 36) | def hunkCount(self, row):
    method cursorLines (line 40) | def cursorLines(self):
    method iterload (line 52) | def iterload(self):
    method openRow (line 94) | def openRow(self, row):
  class HunkViewer (line 98) | class HunkViewer(GitSheet):
    method draw (line 109) | def draw(self, scr):
    method iterload (line 114) | def iterload(self):
  function git_apply (line 148) | def git_apply(sheet, row, *args):

FILE: visidata/apps/vgit/gitsheet.py
  class GitSheet (line 6) | class GitSheet(Sheet):
    method gitargstr (line 8) | def gitargstr(self):
    method git (line 11) | def git(self, subcmd, *args, **kwargs):
    method loggit (line 20) | def loggit(self, subcmd, *args, **kwargs):
    method git_all (line 29) | def git_all(self, *args, **kwargs):
    method git_lines (line 45) | def git_lines(self, subcmd, *args, **kwargs):
    method git_iter (line 69) | def git_iter(self, subcmd, *args, sep='\0', **kwargs):
    method modifyGit (line 109) | def modifyGit(self, *args, **kwargs):
    method gitRootSheet (line 121) | def gitRootSheet(self):
    method iterload (line 126) | def iterload(self):
  function gitRootPath (line 132) | def gitRootPath(self):
  function branch (line 148) | def branch(self):

FILE: visidata/apps/vgit/grep.py
  function git_grep (line 7) | def git_grep(vd, p, args):
  class GitGrep (line 11) | class GitGrep(GitSheet):
    method iterload (line 26) | def iterload(self):

FILE: visidata/apps/vgit/log.py
  function git_log (line 9) | def git_log(vd, p, *args):
  class GitLogSheet (line 13) | class GitLogSheet(GitSheet):
    method __init__ (line 34) | def __init__(self, *args, **kwargs):
    method inRemoteBranch (line 38) | def inRemoteBranch(self, commitid):
    method iterload (line 41) | def iterload(self):
    method openRow (line 54) | def openRow(self, row):
    method commit (line 59) | def commit(self, path, adds, mods, dels):

FILE: visidata/apps/vgit/main.py
  function vgit_cli (line 14) | def vgit_cli():

FILE: visidata/apps/vgit/remote.py
  function git_remote (line 6) | def git_remote(vd, p, args):
  class GitRemotes (line 11) | class GitRemotes(GitSheet):
    method set_remote (line 30) | def set_remote(self, col, row, val):
    method set_url (line 33) | def set_url(self, col, row, val):
    method iterload (line 36) | def iterload(self):
    method commitDeleteRow (line 41) | def commitDeleteRow(self, row):
    method commitAddRow (line 44) | def commitAddRow(self, row):
    method newRow (line 49) | def newRow(self):

FILE: visidata/apps/vgit/repos.py
  function guess_git (line 6) | def guess_git(vd, p):
  function open_git (line 12) | def open_git(vd, p):
  function git_repos (line 17) | def git_repos(vd, p, args):
  class GitLinesColumn (line 21) | class GitLinesColumn(Column):
    method __init__ (line 22) | def __init__(self, name, cmd, *args, **kwargs):
    method calcValue (line 29) | def calcValue(self, r):
  class GitAllColumn (line 35) | class GitAllColumn(GitLinesColumn):
    method calcValue (line 36) | def calcValue(self, r):
  class GitRepos (line 41) | class GitRepos(GitSheet):
    method iterload (line 60) | def iterload(self):
    method openRow (line 66) | def openRow(self, row):
    method openCell (line 69) | def openCell(self, col, row):

FILE: visidata/apps/vgit/stash.py
  function git_stash (line 9) | def git_stash(vd, p, args):
  class GitStashes (line 14) | class GitStashes(GitSheet):
    method iterload (line 32) | def iterload(self):
    method openRow (line 50) | def openRow(self, row):

FILE: visidata/apps/vgit/status.py
  function git_status (line 17) | def git_status(vd, p, args, **kwargs):
  class GitFile (line 23) | class GitFile:
    method __init__ (line 24) | def __init__(self, path, gitsrc):
    method __str__ (line 29) | def __str__(self):
  class GitStatus (line 32) | class GitStatus(GitSheet):
    method statusText (line 67) | def statusText(self, st):
    method workdir (line 82) | def workdir(self):
    method git_status (line 85) | def git_status(self, r):
    method ignored (line 101) | def ignored(self, fn):
    method remotediff (line 111) | def remotediff(self):
    method iterload (line 114) | def iterload(self):
    method openRow (line 156) | def openRow(self, row):
    method openRows (line 163) | def openRows(self, rows):
  function _cachedStatus (line 169) | def _cachedStatus(self):

FILE: visidata/apps/vgit/statusbar.py
  function progressStatus (line 7) | def progressStatus(sheet):
  function branchStatus (line 13) | def branchStatus(sheet):
  function gitInProgress (line 20) | def gitInProgress(sheet):

FILE: visidata/basesheet.py
  class LazyChainMap (line 9) | class LazyChainMap:
    method __init__ (line 11) | def __init__(self, *objs, locals=None):
    method __iter__ (line 19) | def __iter__(self):
    method __contains__ (line 22) | def __contains__(self, k):
    method keys (line 25) | def keys(self):
    method get (line 28) | def get(self, key, default=None):
    method clear (line 33) | def clear(self):
    method __getitem__ (line 36) | def __getitem__(self, k):
    method __setitem__ (line 42) | def __setitem__(self, k, v):
  class DrawablePane (line 49) | class DrawablePane(Extensible):
    method __init__ (line 50) | def __init__(self, **kwargs):
    method draw (line 54) | def draw(self, scr):
    method windowHeight (line 59) | def windowHeight(self):
    method windowWidth (line 64) | def windowWidth(self):
    method currow (line 69) | def currow(self):
    method execCommand2 (line 72) | def execCommand2(self, cmd, vdglobals=None):
  class _dualproperty (line 87) | class _dualproperty:
    method __init__ (line 89) | def __init__(self, obj_method, cls_method):
    method __get__ (line 93) | def __get__(self, obj, objtype=None):
  class BaseSheet (line 100) | class BaseSheet(DrawablePane):
    method _obj_options (line 110) | def _obj_options(self):
    method _class_options (line 113) | def _class_options(cls):
    method __init__ (line 118) | def __init__(self, *names, rows=UNLOADED, **kwargs):
    method setModified (line 132) | def setModified(self):
    method __lt__ (line 137) | def __lt__(self, other):
    method __copy__ (line 143) | def __copy__(self):
    method __bool__ (line 152) | def __bool__(self):
    method __len__ (line 156) | def __len__(self):
    method __str__ (line 160) | def __str__(self):
    method rows (line 164) | def rows(self):
    method rows (line 168) | def rows(self, rows):
    method nRows (line 172) | def nRows(self):
    method __contains__ (line 176) | def __contains__(self, vs):
    method displaySource (line 184) | def displaySource(self):
    method execCommand (line 195) | def execCommand(self, longname, vdglobals=None, keystrokes=None):
    method lastCommandThreads (line 237) | def lastCommandThreads(self):
    method names (line 241) | def names(self):
    method names (line 245) | def names(self, names):
    method name (line 252) | def name(self):
    method name (line 257) | def name(self, name):
    method maybeClean (line 264) | def maybeClean(self, s):
    method recalc (line 268) | def recalc(self):
    method refresh (line 272) | def refresh(self):
    method ensureLoaded (line 276) | def ensureLoaded(self):
    method reload (line 282) | def reload(self):
    method cursorRow (line 287) | def cursorRow(self):
    method checkCursor (line 291) | def checkCursor(self):
    method evalExpr (line 295) | def evalExpr(self, expr, **kwargs):
    method formatString (line 299) | def formatString(self, fmt, **kwargs):
  function redraw (line 305) | def redraw(vd):
  function sheet (line 317) | def sheet(self):
  function isLongname (line 322) | def isLongname(self, ks:str):
  function getSheet (line 328) | def getSheet(vd, sheetname):

FILE: visidata/bezier.py
  function bezier (line 4) | def bezier(x1, y1, x2, y2, x3, y3):
  function _recursive_bezier (line 11) | def _recursive_bezier(x1, y1, x2, y2, x3, y3, level=0):

FILE: visidata/canvas.py
  class Point (line 20) | class Point:
    method __init__ (line 21) | def __init__(self, x, y):
    method __repr__ (line 25) | def __repr__(self):
    method xy (line 32) | def xy(self):
  class Box (line 35) | class Box:
    method __init__ (line 36) | def __init__(self, x, y, w=0, h=0):
    method __repr__ (line 42) | def __repr__(self):
    method xymin (line 46) | def xymin(self):
    method xmax (line 50) | def xmax(self):
    method ymax (line 54) | def ymax(self):
    method center (line 58) | def center(self):
    method xcenter (line 62) | def xcenter(self):
    method ycenter (line 66) | def ycenter(self):
    method contains (line 69) | def contains(self, x, y):
  function BoundingBox (line 75) | def BoundingBox(x1, y1, x2, y2):
  function clipline (line 79) | def clipline(x1, y1, x2, y2, xmin, ymin, xmax, ymax):
  function iterline (line 111) | def iterline(x1, y1, x2, y2):
  function anySelected (line 132) | def anySelected(vs, rows):
  class Plotter (line 139) | class Plotter(BaseSheet):
    method __init__ (line 143) | def __init__(self, *names, **kwargs):
    method nRows (line 151) | def nRows(self):
    method resetCanvasDimensions (line 154) | def resetCanvasDimensions(self, windowHeight, windowWidth):
    method plotpixel (line 162) | def plotpixel(self, x, y, attr:"str|ColorAttr=''", row=None):
    method plotline (line 165) | def plotline(self, x1, y1, x2, y2, attr:"str|ColorAttr=''", row=None):
    method plotlabel (line 169) | def plotlabel(self, x, y, text, attr:"str|ColorAttr=''", row=None):
    method plotlegend (line 172) | def plotlegend(self, i, txt, attr:"str|ColorAttr=''", width=15):
    method plotterCursorBox (line 177) | def plotterCursorBox(self):
    method plotterMouse (line 182) | def plotterMouse(self):
    method plotterFromTerminalCoord (line 185) | def plotterFromTerminalCoord(self, x, y):
    method getPixelAttrRandom (line 188) | def getPixelAttrRandom(self, x, y) -> str:
    method getPixelAttrMost (line 194) | def getPixelAttrMost(self, x, y) -> str:
    method hideAttr (line 205) | def hideAttr(self, attr:str, hide=True):
    method rowsWithin (line 212) | def rowsWithin(self, plotter_bbox, invert_y=False):
    method draw (line 235) | def draw(self, scr):
    method draw_empty (line 243) | def draw_empty(self, scr):
    method draw_pixels (line 256) | def draw_pixels(self, scr, clear_empty_squares=True):
    method draw_labels (line 302) | def draw_labels(self, scr):
  class Canvas (line 352) | class Canvas(Plotter):
    method __init__ (line 361) | def __init__(self, *names, **kwargs):
    method nRows (line 382) | def nRows(self):
    method reset (line 385) | def reset(self):
    method plotColor (line 397) | def plotColor(self, k) -> str:
    method resetCanvasDimensions (line 413) | def resetCanvasDimensions(self, windowHeight, windowWidth):
    method statusLine (line 450) | def statusLine(self):
    method canvasMouse (line 454) | def canvasMouse(self):
    method setCursorSize (line 461) | def setCursorSize(self, p):
    method setCursorSizeInPlotterPixels (line 468) | def setCursorSizeInPlotterPixels(self, w, h):
    method formatX (line 472) | def formatX(self, v):
    method formatY (line 475) | def formatY(self, v):
    method commandCursor (line 478) | def commandCursor(sheet, execstr):
    method canvasCharWidth (line 493) | def canvasCharWidth(self):
    method canvasCharHeight (line 498) | def canvasCharHeight(self):
    method plotterVisibleBox (line 503) | def plotterVisibleBox(self):
    method plotterCursorBox (line 510) | def plotterCursorBox(self):
    method startCursor (line 518) | def startCursor(self):
    method point (line 526) | def point(self, x, y, attr:"str|ColorAttr=''", row=None):
    method line (line 529) | def line(self, x1, y1, x2, y2, attr:"str|ColorAttr=''", row=None):
    method polyline (line 532) | def polyline(self, vertexes, attr:"str|ColorAttr=''", row=None):
    method polygon (line 536) | def polygon(self, vertexes, attr:"str|ColorAttr=''", row=None):
    method qcurve (line 540) | def qcurve(self, vertexes, attr:"str|ColorAttr=''", row=None):
    method label (line 552) | def label(self, x, y, text, attr:"str|ColorAttr=''", row=None):
    method fixPoint (line 555) | def fixPoint(self, plotterPoint, canvasPoint):
    method zoomTo (line 561) | def zoomTo(self, bbox):
    method incrZoom (line 568) | def incrZoom(self, incr):
    method resetBounds (line 574) | def resetBounds(self, refresh=True):
    method calcTopCursorY (line 618) | def calcTopCursorY(self):
    method calcBottomCursorY (line 627) | def calcBottomCursorY(self):
    method plotlegends (line 631) | def plotlegends(self):
    method checkCursor (line 640) | def checkCursor(self):
    method xScaler (line 651) | def xScaler(self):
    method yScaler (line 660) | def yScaler(self):
    method calcVisibleBoxWidth (line 668) | def calcVisibleBoxWidth(self):
    method calcVisibleBoxHeight (line 681) | def calcVisibleBoxHeight(self):
    method scaleX (line 694) | def scaleX(self, canvasX) -> int:
    method scaleY (line 698) | def scaleY(self, canvasY) -> int:
    method unscaleX (line 702) | def unscaleX(self, plotterX):
    method unscaleY (line 706) | def unscaleY(self, plotterY):
    method canvasW (line 710) | def canvasW(self, plotter_width):
    method canvasH (line 714) | def canvasH(self, plotter_height):
    method refresh (line 718) | def refresh(self):
    method render (line 722) | def render(self, h, w):
    method render_async (line 732) | def render_async(self):
    method plot_elements (line 735) | def plot_elements(self, invert_y=False):
    method deleteSourceRows (line 783) | def deleteSourceRows(self, rows):

FILE: visidata/canvas_text.py
  function boundingBox (line 5) | def boundingBox(rows):
  class CharBox (line 18) | class CharBox:
    method __init__ (line 19) | def __init__(self, scr=None, x1=0, y1=0, w=None, h=None):
    method __str__ (line 29) | def __str__(self):
    method normalize (line 32) | def normalize(self):
    method x2 (line 43) | def x2(self):
    method x2 (line 47) | def x2(self, v):
    method y2 (line 52) | def y2(self):
    method y2 (line 56) | def y2(self, v):
    method contains (line 60) | def contains(self, b):
  class TextCanvas (line 69) | class TextCanvas(BaseSheet):
    method rows (line 71) | def rows(self):
    method rows (line 75) | def rows(self, v):
    method minXY (line 79) | def minXY(self) -> int:
    method maxXY (line 84) | def maxXY(self) -> int:
    method reload (line 88) | def reload(self):
    method draw (line 91) | def draw(self, scr):
    method commandCursor (line 96) | def commandCursor(self, execstr):
    method checkCursor (line 101) | def checkCursor(self):
    method iterbox (line 105) | def iterbox(self, box, n=None):
    method itercursor (line 115) | def itercursor(self, n=None):
    method cursorRows (line 119) | def cursorRows(self):
    method slide (line 122) | def slide(self, rows, dx, dy):

FILE: visidata/choose.py
  function chooseOne (line 8) | def chooseOne(vd, choices, type=''):
  function choose (line 14) | def choose(vd, choices, n=None, type=''):
  class ChoiceSheet (line 22) | class ChoiceSheet(ListOfDictSheet):
    method makeChoice (line 25) | def makeChoice(self, rows):
  function chooseFancy (line 30) | def chooseFancy(vd, choices):
  function chooseMany (line 42) | def chooseMany(vd, choices, type=''):

FILE: visidata/clean_names.py
  function cleanName (line 9) | def cleanName(vd, s):
  function maybeClean (line 19) | def maybeClean(sheet, s):

FILE: visidata/clipboard.py
  function setClipboardRows (line 40) | def setClipboardRows(vd, rows):
  function getClipboardRows (line 44) | def getClipboardRows(vd):
  function setClipboardCols (line 48) | def setClipboardCols(vd, cols):
  function getClipboardCols (line 52) | def getClipboardCols(vd):
  function copyRows (line 56) | def copyRows(sheet, rows):
  function copyCells (line 65) | def copyCells(sheet, col, rows):
  function syscopyValue (line 74) | def syscopyValue(sheet, val):
  function setColClipboard (line 86) | def setColClipboard(sheet):
  function syscopyCells (line 93) | def syscopyCells(sheet, cols, rows, filetype=None):
  function syscopyCells_async (line 100) | def syscopyCells_async(sheet, cols, rows, filetype):
  function sysclipValue (line 120) | def sysclipValue(vd):
  function pasteFromClipboard (line 127) | def pasteFromClipboard(vd, cols, rows):
  function delete_row (line 148) | def delete_row(sheet, rowidx):
  function paste_after (line 168) | def paste_after(sheet, rowidx):

FILE: visidata/cliptext.py
  function wcwidth (line 44) | def wcwidth(cc, ambig=1):
  function is_vdcode (line 60) | def is_vdcode(s:str) -> bool:
  function escape_vdcode (line 64) | def escape_vdcode(s:str) -> str:
  function is_marked_literal (line 68) | def is_marked_literal(s):
  function iterchunks (line 71) | def iterchunks(s, literal=False):
  function dispwidth (line 111) | def dispwidth(ss, maxwidth=None, literal=False):
  function _dispch (line 126) | def _dispch(c, oddspacech=None, combch=None, modch=None):
  function iterchars (line 139) | def iterchars(x):
  function _clipstr (line 160) | def _clipstr(s, dispw, trunch='', oddspacech='', combch='', modch=''):
  function clipstr (line 204) | def clipstr(s, dispw, truncator=None, oddspace=None):
  function clipdraw (line 221) | def clipdraw(scr, y, x, s, attr, w=None, clear=True, literal=False, **kw...
  function _addstr (line 238) | def _addstr(scr, y, x, s, attr):
  function clipdraw_chunks (line 246) | def clipdraw_chunks(scr, y, x, chunks, cattr:ColorAttr=ColorAttr(), w=No...
  function _markdown_to_internal (line 322) | def _markdown_to_internal(text):
  function wraptext (line 332) | def wraptext(text, width=80, indent=''):
  function clipstr_start (line 423) | def clipstr_start(dispval, w, truncator='', literal=False):
  function clipstr_middle (line 441) | def clipstr_middle(s, n=10, truncator='…'):
  function clip_markup_middle (line 457) | def clip_markup_middle(s:str, w:int):

FILE: visidata/cmdlog.py
  function queueCommand (line 27) | def queueCommand(vd, longname, input=None, sheet=None, col=None, row=None):
  function open_vd (line 33) | def open_vd(vd, p):
  function open_vdj (line 37) | def open_vdj(vd, p):
  function save_vdj (line 44) | def save_vdj(vd, p, *vsheets):
  function checkVersion (line 52) | def checkVersion(vd, desired_version):
  function fnSuffix (line 57) | def fnSuffix(vd, prefix:str):
  function indexMatch (line 66) | def indexMatch(L, func):
  function isLoggableCommand (line 73) | def isLoggableCommand(vd, cmd):
  function isLoggableSheet (line 83) | def isLoggableSheet(sheet):
  function moveToRow (line 88) | def moveToRow(vs, rowstr):
  function getRowIndexFromStr (line 99) | def getRowIndexFromStr(vs, row):
  function moveToCol (line 117) | def moveToCol(vs, col):
  function commandCursor (line 133) | def commandCursor(sheet, execstr):
  class CommandLogBase (line 149) | class CommandLogBase:
    method newRow (line 167) | def newRow(self, **fields):
    method beforeExecHook (line 170) | def beforeExecHook(self, sheet, cmd, args, keystrokes):
    method afterExecSheet (line 196) | def afterExecSheet(self, sheet, escaped, err):
    method openHook (line 213) | def openHook(self, vs, src):
  class CommandLog (line 220) | class CommandLog(CommandLogBase, VisiDataMetaSheet):
  class CommandLogJsonl (line 223) | class CommandLogJsonl(CommandLogBase, JsonLinesSheet):
    method newRow (line 227) | def newRow(self, **fields):
    method iterload (line 230) | def iterload(self):
  function replay_cancel (line 246) | def replay_cancel(vd):
  function moveToReplayContext (line 253) | def moveToReplayContext(vd, r, vs):
  function replayOne (line 267) | def replayOne(vd, r):
  class DisableAsync (line 320) | class DisableAsync:
    method __enter__ (line 321) | def __enter__(self):
    method __exit__ (line 324) | def __exit__(self, exc_type, exc_val, tb):
  function replay_sync (line 329) | def replay_sync(vd, cmdlog):
  function replay (line 370) | def replay(vd, cmdlog):
  function getLastArgs (line 377) | def getLastArgs(vd):
  function setLastArgs (line 385) | def setLastArgs(vd, args):
  function replayStatus (line 394) | def replayStatus(vd):
  function cmdlog (line 405) | def cmdlog(sheet):
  function cmdlog_sheet (line 413) | def cmdlog_sheet(sheet):
  function shortcut (line 425) | def shortcut(self):
  function cmdlog (line 442) | def cmdlog(vd):
  function modifyCommand (line 450) | def modifyCommand(vd):

FILE: visidata/color.py
  class ColorAttr (line 23) | class ColorAttr:
    method __init__ (line 30) | def __init__(self, fg:int=-1, bg:int=-1, attributes:int=0, precedence:...
    method update (line 39) | def update(self, b:'ColorAttr', prec:int=10) -> 'ColorAttr':
    method attr (line 43) | def attr(self) -> int:
    method as_str (line 48) | def as_str(self) -> str:
  function update_attr (line 54) | def update_attr(oldattr:ColorAttr, updattr:ColorAttr, updprec:int=None) ...
  class ColorMaker (line 78) | class ColorMaker:
    method __init__ (line 79) | def __init__(self):
    method colorattr_cache (line 84) | def colorattr_cache(self):
    method setup (line 88) | def setup(self):
    method colors (line 95) | def colors(self):
    method __getitem__ (line 99) | def __getitem__(self, colorname:str) -> ColorAttr:
    method __getattr__ (line 103) | def __getattr__(self, optname) -> ColorAttr:
    method resolve_colors (line 108) | def resolve_colors(self, colorstack):
    method get_color (line 116) | def get_color(self, optname:str, precedence:int=0) -> ColorAttr:
    method _split_colorstr (line 126) | def _split_colorstr(self, colorstr):
    method _get_colornum (line 153) | def _get_colornum(self, colorname:'str|int', default:int=-1) -> int:
    method _attrnames_to_num (line 182) | def _attrnames_to_num(self, attrnames:'list[str]') -> int:
    method _attrs (line 189) | def _attrs(self):
    method _colornames_to_cattr (line 193) | def _colornames_to_cattr(self, colorname:str, precedence=0) -> ColorAttr:
    method _get_colorpair (line 202) | def _get_colorpair(self, fg:'int|None', bg:'int|None', colorname:str) ...
  function rgb_to_xterm256 (line 224) | def rgb_to_xterm256(r:int,g:int,b:int,a:int=255) -> int:
  function xterm256_to_css (line 242) | def xterm256_to_css(n:'str|int') -> str:
  function xterm256_to_rgb (line 248) | def xterm256_to_rgb(n:'str|int') -> tuple:
  function rgb_to_attr (line 285) | def rgb_to_attr(r:int,g:int,b:int,a:int=255) -> str:
  function css_to_xterm256 (line 289) | def css_to_xterm256(csscolor:str) -> str:

FILE: visidata/column.py
  class InProgress (line 16) | class InProgress(Exception):
    method stacktrace (line 18) | def stacktrace(self):
  class DisplayWrapper (line 28) | class DisplayWrapper:
    method __init__ (line 29) | def __init__(self, value=None, *, typedval=None, text='', note=None, n...
    method __bool__ (line 37) | def __bool__(self):
    method __eq__ (line 40) | def __eq__(self, other):
  class Column (line 44) | class Column(Extensible):
    method __init__ (line 61) | def __init__(self, name=None, *, type=anytype, cache=False, **kwargs):
    method __copy__ (line 88) | def __copy__(self):
    method __str__ (line 97) | def __str__(self):
    method __repr__ (line 100) | def __repr__(self):
    method __deepcopy__ (line 103) | def __deepcopy__(self, memo):
    method __getstate__ (line 106) | def __getstate__(self):
    method __setstate__ (line 109) | def __setstate__(self, d):
    method recalc (line 113) | def recalc(self, sheet=None):
    method name (line 122) | def name(self):
    method name (line 127) | def name(self, name):
    method setName (line 130) | def setName(self, name):
    method typestr (line 144) | def typestr(self):
    method typestr (line 149) | def typestr(self, v):
    method type (line 153) | def type(self):
    method type (line 158) | def type(self, t):
    method width (line 169) | def width(self):
    method width (line 174) | def width(self, w):
    method formatted_help (line 181) | def formatted_help(self):
    method help_formatters (line 185) | def help_formatters(self):
    method help_displayers (line 190) | def help_displayers(self):
    method _formatdict (line 195) | def _formatdict(col):
    method fmtstr (line 201) | def fmtstr(self):
    method fmtstr (line 206) | def fmtstr(self, v):
    method _format_len (line 209) | def _format_len(self, typedval, **kwargs):
    method formatter_len (line 217) | def formatter_len(self, fmtstr):
    method formatter_generic (line 220) | def formatter_generic(self, fmtstr):
    method formatter_json (line 223) | def formatter_json(self, fmtstr):
    method formatter_python (line 226) | def formatter_python(self, fmtstr):
    method make_formatter (line 230) | def make_formatter(self):
    method format (line 235) | def format(self, *args, **kwargs):
    method formatValue (line 238) | def formatValue(self, typedval, width=None):
    method displayer_generic (line 258) | def displayer_generic(self, dw:DisplayWrapper, width=None):
    method displayer_full (line 271) | def displayer_full(self, dw:DisplayWrapper, width=None):
    method display (line 282) | def display(self, *args, **kwargs):
    method hide (line 286) | def hide(self, hide=True):
    method readonly (line 293) | def readonly(self):
    method hidden (line 297) | def hidden(self):
    method calcValue (line 303) | def calcValue(self, row):
    method getTypedValue (line 307) | def getTypedValue(self, row):
    method setCache (line 311) | def setCache(self, cache):
    method _calcIntoCacheAsync (line 321) | def _calcIntoCacheAsync(self, row):
    method _calcIntoCache (line 326) | def _calcIntoCache(self, row):
    method getValue (line 332) | def getValue(self, row):
    method getCell (line 360) | def getCell(self, row):
    method getDisplayValue (line 423) | def getDisplayValue(self, row):
    method getFullDisplayValue (line 428) | def getFullDisplayValue(self, row):
    method putValue (line 438) | def putValue(self, row, val):
    method setValue (line 443) | def setValue(self, row, val, setModified=True):
    method setValues (line 453) | def setValues(self, rows, *values):
    method setValuesTyped (line 473) | def setValuesTyped(self, rows, *values):
    method getMaxWidth (line 492) | def getMaxWidth(self, rows):
    method measureValueWidthCapped (line 505) | def measureValueWidthCapped(self, row, maxwidth=None):
  class WritableColumn (line 527) | class WritableColumn(Column):
    method readonly (line 529) | def readonly(self):
  class AttrColumn (line 532) | class AttrColumn(WritableColumn):
    method __init__ (line 534) | def __init__(self, name=None, expr=None, **kwargs):
    method putValue (line 540) | def putValue(self, row, val):
  class ItemColumn (line 545) | class ItemColumn(WritableColumn):
    method __init__ (line 547) | def __init__(self, name=None, expr=None, **kwargs):
    method putValue (line 553) | def putValue(self, row, val):
  class SubColumnFunc (line 558) | class SubColumnFunc(Column):
    method __init__ (line 560) | def __init__(self, name='', origcol=None, expr=None, subfunc=getitemde...
    method readonly (line 566) | def readonly(self):
    method calcValue (line 569) | def calcValue(self, row):
    method putValue (line 575) | def putValue(self, row, value):
    method recalc (line 581) | def recalc(self, sheet=None):
  function SubColumnAttr (line 586) | def SubColumnAttr(attrname, c, **kwargs):
  function SubColumnItem (line 591) | def SubColumnItem(idx, c, **kwargs):
  class SettableColumn (line 597) | class SettableColumn(WritableColumn):
    method putValue (line 599) | def putValue(self, row, value):
    method calcValue (line 602) | def calcValue(self, row):

FILE: visidata/ddwplay.py
  class AttrDict (line 9) | class AttrDict(dict):
    method __getattr__ (line 10) | def __getattr__(self, k):
    method __setattr__ (line 20) | def __setattr__(self, k, v):
    method __dir__ (line 22) | def __dir__(self):
  class Animation (line 26) | class Animation:
    method __init__ (line 27) | def __init__(self, fp):
    method iterdeep (line 34) | def iterdeep(self, rows, x=0, y=0, parents=None, **kwargs):
    method matches (line 49) | def matches(self, row, values):
    method load_from (line 59) | def load_from(self, fp):
    method draw (line 83) | def draw(self, scr, *, t=0, x=0, y=0, loop=False, attr=ColorAttr(), **...
  class AnimationMgr (line 108) | class AnimationMgr:
    method __init__ (line 109) | def __init__(self):
    method trigger (line 113) | def trigger(self, name, **kwargs):
    method load (line 119) | def load(self, name, fp):
    method maxHeight (line 123) | def maxHeight(self):
    method maxWidth (line 127) | def maxWidth(self):
    method draw (line 130) | def draw(self, scr, t=None, **kwargs):

FILE: visidata/deprecated.py
  function deprecated_alias (line 6) | def deprecated_alias(depver, *args, **kwargs):
  function deprecated_warn (line 12) | def deprecated_warn(vd, funcname, ver, instead):
  function deprecated (line 27) | def deprecated(ver, instead='', check=True):
  function _deprecated_api (line 41) | def _deprecated_api(ver, instead=''):
  function __call__ (line 48) | def __call__(vd):
  function copyToClipboard (line 54) | def copyToClipboard(value):
  function replayableOption (line 60) | def replayableOption(optname, default, helpstr):
  function SubrowColumn (line 64) | def SubrowColumn(*args, **kwargs):
  function DeferredSetColumn (line 68) | def DeferredSetColumn(*args, **kwargs):
  function bindkey_override (line 72) | def bindkey_override(keystrokes, longname):
  function exec_keystrokes (line 80) | def exec_keystrokes(self, keystrokes, vdglobals=None):
  function filetype (line 87) | def filetype(vd, ext, constructor):
  function joinSheetnames (line 93) | def joinSheetnames(vd, *sheetnames):
  function load_pyobj (line 99) | def load_pyobj(*names, **kwargs):
  function push_pyobj (line 104) | def push_pyobj(name, pyobj):
  function isNumeric (line 112) | def isNumeric(col):
  function clean_name (line 151) | def clean_name(s):
  function maybe_clean (line 154) | def maybe_clean(s, vs):
  function load_tsv (line 159) | def load_tsv(fn):
  function itemsetter (line 185) | def itemsetter(i):
  function clean_to_id (line 200) | def clean_to_id(s):
  class OnExit (line 204) | class OnExit:
    method __init__ (line 206) | def __init__(self, func, *args, **kwargs):
    method __enter__ (line 211) | def __enter__(self):
    method __exit__ (line 214) | def __exit__(self, exc_type, exc_value, exc_traceback):
  function inputRegexSubstOld (line 225) | def inputRegexSubstOld(vd, prompt):
  function setValueSafe (line 244) | def setValueSafe(self, row, value):
  function checkCursorNoExceptions (line 250) | def checkCursorNoExceptions(sheet):
  function memo (line 255) | def memo(vd, name, col, row):
  function keystr (line 264) | def keystr(sheet, row):
  function toggleKeys (line 271) | def toggleKeys(self, cols):

FILE: visidata/editor.py
  class SuspendCurses (line 12) | class SuspendCurses:
    method __enter__ (line 14) | def __enter__(self):
    method __exit__ (line 20) | def __exit__(self, exc_type, exc_val, tb):
  function launchEditor (line 28) | def launchEditor(vd, *args):
  function launchBrowser (line 37) | def launchBrowser(vd, *args):
  function launchExternalEditor (line 46) | def launchExternalEditor(vd, v, linenum=0):
  function launchExternalEditorPath (line 57) | def launchExternalEditorPath(vd, path, linenum=0):
  function suspend (line 73) | def suspend(vd):
  function _breakpoint (line 79) | def _breakpoint(*args, **kwargs):

FILE: visidata/errors.py
  class ExpectedException (line 10) | class ExpectedException(Exception):
  function stacktrace (line 15) | def stacktrace(e=None, exclude_caller=False):
  function exceptionCaught (line 55) | def exceptionCaught(vd, exc=None, status=True, **kwargs):

FILE: visidata/experimental/daw/merge_transcripts.py
  function stderr (line 8) | def stderr(*args):
  function progress (line 11) | def progress(s):
  function find_words_around (line 15) | def find_words_around(needle:dict, haystack:list[dict], seconds=10):
  function _score (line 20) | def _score(whisperw, humanw):
  function clean (line 32) | def clean(s:str) -> str:
  function main (line 35) | def main(humanfn, *whisperfns):

FILE: visidata/experimental/daw/mpv.py
  class MpvProcess (line 15) | class MpvProcess:
    method __init__ (line 71) | def __init__(self, sourcefn, source:Sheet):
    method add_filter (line 76) | def add_filter(self, filtername):
    method remove_filter (line 82) | def remove_filter(self, filtername):
    method set_filter_parm (line 85) | def set_filter_parm(self, filtername, parmname, val):
    method mpvsockfn (line 92) | def mpvsockfn(self):
    method restart_mpv (line 95) | def restart_mpv(self, t:float):
    method is_default (line 101) | def is_default(self, filtername, parmname, val):
    method start_mpv (line 104) | def start_mpv(self):
    method mpv_command (line 131) | def mpv_command(self, **kwargs):
    method mpv_query (line 137) | def mpv_query(self, propname):
    method set_property (line 154) | def set_property(self, propname, b=True):
    method paused (line 158) | def paused(self):
    method playback_time (line 164) | def playback_time(self):
    method pause_audio (line 169) | def pause_audio(self, b=True):
    method play_audio (line 172) | def play_audio(self, t:float):
    method seek_audio (line 176) | def seek_audio(self, dt:float, *args):

FILE: visidata/experimental/daw/vdaw.py
  function to_hms (line 23) | def to_hms(t:float, width=None) -> str:
  function cleanword (line 48) | def cleanword(s:str) -> str:
  function is_cut (line 51) | def is_cut(row):
  function replace_subrows (line 58) | def replace_subrows(row):
  function open_transcript (line 74) | def open_transcript(vd, p):
  function formatter_hhmmss (line 80) | def formatter_hhmmss(self, fmtstr):
  class EditRow (line 84) | class EditRow:
    method __init__ (line 85) | def __init__(self, section:str='', speaker:str='', header:str='', subr...
    method __str__ (line 97) | def __str__(self):
    method to_json (line 101) | def to_json(self) -> dict:
    method __contains__ (line 110) | def __contains__(self, t:float) -> bool:
    method start (line 118) | def start(self) -> float:
    method end (line 123) | def end(self) -> float:
    method duration (line 128) | def duration(self) -> float:
    method raw_duration (line 137) | def raw_duration(self) -> float:
    method text (line 141) | def text(self) -> str:
    method editedtext (line 151) | def editedtext(self) -> str:
    method cookedtext (line 164) | def cookedtext(self) -> str:
    method uncutrows (line 174) | def uncutrows(self) -> list:
    method nwords (line 180) | def nwords(self) -> int:
    method split_at_word (line 183) | def split_at_word(self, n:int) -> tuple['EditRow', 'EditRow']:
    method split_at_time (line 214) | def split_at_time(self, t:float) -> tuple['EditRow', 'EditRow']:
  class PodcastEditingSheet (line 258) | class PodcastEditingSheet(Sheet):
    method iterload (line 288) | def iterload(self):
    method openRows (line 329) | def openRows(self, rows):
    method openRow (line 340) | def openRow(self, row):
    method combine_rows (line 346) | def combine_rows(self, rows):
    method expand_row (line 359) | def expand_row(self, rowidx):
    method bump (line 371) | def bump(self, n, *rows):
    method set_speaker_recursive (line 378) | def set_speaker_recursive(self, row, speaker):
    method set_text_recursive (line 385) | def set_text_recursive(self, row, newtext):
    method cycle_speaker (line 409) | def cycle_speaker(self, row):
    method getRowIndexByPlaytime (line 416) | def getRowIndexByPlaytime(self, t:float, rows=None) -> int:
    method checkCursor (line 422) | def checkCursor(self):
    method find_row_path (line 449) | def find_row_path(self, t:float, rows:list['EditRow']=None) -> list['E...
    method is_cut (line 474) | def is_cut(self, t:float):
    method go_playhead (line 480) | def go_playhead(self):
    method split_at_playhead (line 484) | def split_at_playhead(self):
    method split_at_input (line 495) | def split_at_input(self, rowidx, word:str):
    method go_header_next (line 513) | def go_header_next(self, didx:int, startrow:int):
    method playheadStatus (line 523) | def playheadStatus(self):
    method setFilterParmByIndex (line 530) | def setFilterParmByIndex(self, filtername, parmname, idxvalue):
    method reformat_row (line 533) | def reformat_row(self, rowidx, undo=True):
    method reformat_rows (line 554) | def reformat_rows(self, rows):
    method bulk_combine (line 560) | def bulk_combine(self, rows):
    method speed_change (line 564) | def speed_change(self, dv):
    method words (line 569) | def words(self):
    method flag_bad_timings (line 574) | def flag_bad_timings(self):
  function iterwords (line 619) | def iterwords(segs):
  class FilterParametersSheet (line 628) | class FilterParametersSheet(Sheet):
    method iterload (line 639) | def iterload(self):
  function save_cutlist (line 651) | def save_cutlist(vd, p, sheet):
  function iterspeakerrows (line 676) | def iterspeakerrows(rows, include_cuts=True, inline_interjections=False,...
  function save_xmd (line 732) | def save_xmd(vd, p, sheet):
  function _default (line 757) | def _default(self, obj):
  function save_transcript (line 764) | def save_transcript(vd, p, sheet):

FILE: visidata/experimental/daw/xmd2json.py
  function parse_hhmmss (line 15) | def parse_hhmmss(hms:str) -> float:
  function interpolate_times (line 22) | def interpolate_times(pending_rows:list[dict], startt, endt):
  function split_cuts (line 34) | def split_cuts(row, startcut=False):
  function parse_xmd (line 48) | def parse_xmd(xmdfn:str) -> list:
  function main (line 104) | def main(xmdfn):

FILE: visidata/experimental/diff_sheet.py
  function makeDiffColorizer (line 9) | def makeDiffColorizer(othersheet):
  function setDiffSheet (line 25) | def setDiffSheet(vs):

FILE: visidata/experimental/gdrive.py
  function open_gdrive (line 7) | def open_gdrive(vd, p):
  function _drivebuild (line 22) | def _drivebuild(vd):
  function _gdrive (line 26) | def _gdrive(self):
  function _gdrive_rw (line 30) | def _gdrive_rw(self):
  class GDriveSheet (line 34) | class GDriveSheet(Sheet):
    method iterload (line 48) | def iterload(self):
    method openRow (line 67) | def openRow(self, r):
    method deleteFile (line 75) | def deleteFile(self, **kwargs):
    method putChanges (line 81) | def putChanges(self):

FILE: visidata/experimental/gsheets.py
  function open_gsheets (line 8) | def open_gsheets(vd, p):
  function google_discovery (line 16) | def google_discovery(self):
  function _gsheets (line 23) | def _gsheets(vd):
  function _gsheets_rw (line 28) | def _gsheets_rw(vd):
  class GSheetsIndex (line 32) | class GSheetsIndex(Sheet):
    method iterload (line 39) | def iterload(self):
    method openRow (line 46) | def openRow(self, r):
  class GSheet (line 50) | class GSheet(SequenceSheet):
    method iterload (line 52) | def iterload(self):
  function save_gsheets (line 58) | def save_gsheets(vd, p, *sheets):

FILE: visidata/experimental/live_search.py
  function dup_search (line 6) | def dup_search(sheet, cols='cursorCol'):

FILE: visidata/experimental/liveupdate.py
  function updateExpr (line 5) | def updateExpr(col, val):
  function expr (line 16) | def expr(self, expr):
  function addcol_expr (line 25) | def addcol_expr(sheet):

FILE: visidata/experimental/llm.py
  function anthropic_client (line 67) | def anthropic_client(vd):
  function loadLLMTemplate (line 75) | def loadLLMTemplate(vd):
  function queryLLM (line 90) | def queryLLM(vd, prompt):
  function llmAnalyzeColumn (line 123) | def llmAnalyzeColumn(sheet, col, rows, query):

FILE: visidata/experimental/mark.py
  function marks (line 10) | def marks(vd):
  class MarkSheet (line 14) | class MarkSheet(TableSheet):
  class MarksSheet (line 18) | class MarksSheet(TableSheet):
    method __init__ (line 31) | def __init__(self, *args, **kwargs):
    method getColor (line 38) | def getColor(self, sheet, row):
    method getMark (line 44) | def getMark(self, sheet, row):
    method getMarks (line 51) | def getMarks(self, row):
    method isMarked (line 55) | def isMarked(self, row, mark):
    method getMarkRow (line 59) | def getMarkRow(self, sheet, mark):
    method setMark (line 67) | def setMark(self, sheet, row, mark):
    method unsetMark (line 76) | def unsetMark(self, sheet, row, mark):
    method inputmark (line 82) | def inputmark(self):
    method openRow (line 85) | def openRow(self, row):
  function mark (line 91) | def mark(vd, sheet, rows, m):
  function unmark (line 97) | def unmark(vd, sheet, rows, m):

FILE: visidata/experimental/noahs_tapestry/tapestry.py
  function getNoahsPath (line 13) | def getNoahsPath(vd, name):
  function openNoahsText (line 17) | def openNoahsText(vd, name):
  function noahsDatabase (line 21) | def noahsDatabase(vd):
  class NoahsPuzzle (line 24) | class NoahsPuzzle(Sheet):
    method iterload (line 40) | def iterload(self):
  function noahsSolutions (line 54) | def noahsSolutions(vd):
  function solve_puzzle (line 58) | def solve_puzzle(vd, answer):
  class Tapestry (line 68) | class Tapestry(Canvas):
    method guide (line 70) | def guide(self):
    method reload (line 88) | def reload(self):
    method keep_running (line 97) | def keep_running(self):
    method draw (line 101) | def draw(self, scr):
    method open_puzzle (line 120) | def open_puzzle(self, puznum=None):
  function noahsTapestry (line 133) | def noahsTapestry(vd):

FILE: visidata/experimental/rownum.py
  function calcRowIndex (line 7) | def calcRowIndex(sheet, indexes):
  function _rowindex (line 13) | def _rowindex(sheet):
  function rowindex (line 20) | def rowindex(sheet, row):
  function prev (line 26) | def prev(sheet, row):
  function addcol_rowindex (line 33) | def addcol_rowindex(sheet, newcol):
  function addcol_delta (line 51) | def addcol_delta(sheet, vcolidx):
  function addcol_rownum (line 63) | def addcol_rownum(sheet):

FILE: visidata/experimental/slide_cells.py
  function slide_cells_right (line 13) | def slide_cells_right(sheet, row, vcolidx):

FILE: visidata/experimental/sort_selected.py
  function sortSelected (line 6) | def sortSelected(self, ordering):

FILE: visidata/expr.py
  class ExprColumn (line 6) | class ExprColumn(Column):
    method __init__ (line 8) | def __init__(self, name, expr=None, **kwargs):
    method calcValue (line 15) | def calcValue(self, row):
    method expr (line 25) | def expr(self):
    method expr (line 29) | def expr(self, expr):
  class CompleteExpr (line 34) | class CompleteExpr:
    method __init__ (line 35) | def __init__(self, sheet=None):
    method __call__ (line 43) | def __call__(self, val, state):
  function setValuesFromExpr (line 69) | def setValuesFromExpr(self, rows, expr, **kwargs):
  function inputExpr (line 89) | def inputExpr(self, prompt, *args, **kwargs):
  function addcol_expr (line 94) | def addcol_expr(sheet, expr_input, **kwargs):  # #3022

FILE: visidata/extensible.py
  class Extensible (line 6) | class Extensible:
    method init (line 10) | def init(cls, membername, initfunc=lambda: None, copy=False):
    method superclasses (line 38) | def superclasses(cls):
    method api (line 46) | def api(cls, func):
    method before (line 57) | def before(cls, beforefunc):
    method after (line 72) | def after(cls, afterfunc):
    method class_api (line 88) | def class_api(cls, func):
    method property (line 106) | def property(cls, func):
    method lazy_property (line 116) | def lazy_property(cls, func):
    method cached_property (line 131) | def cached_property(cls, func):
    method clear_all_caches (line 143) | def clear_all_caches(cls):
  function cache (line 148) | def cache(func):
  function drawcache_property (line 161) | def drawcache_property(func):

FILE: visidata/features/addcol_audiometadata.py
  function get_mutagen_info (line 9) | def get_mutagen_info(path):
  class MutagenColumn (line 15) | class MutagenColumn(AttrColumn):
    method calcValue (line 16) | def calcValue(self, r):
  function audiometadata_columns (line 22) | def audiometadata_columns(sheet):

FILE: visidata/features/addcol_histogram.py
  class HistogramColumn (line 4) | class HistogramColumn(Column):
    method calcValue (line 5) | def calcValue(col, row):
  function addcol_histogram (line 12) | def addcol_histogram(sheet, col):  #2052
  function calc_histogram_bounds (line 22) | def calc_histogram_bounds(sheet, col):

FILE: visidata/features/canvas_save_svg.py
  function plot_sheet (line 16) | def plot_sheet(self, ax):
  function save_svg (line 57) | def save_svg(vd, p, *sheets):

FILE: visidata/features/change_precision.py
  function setcol_precision (line 20) | def setcol_precision(col, amount:int):

FILE: visidata/features/cmdpalette.py
  function add_to_input (line 23) | def add_to_input(v, i, value=''):
  function accept_input (line 33) | def accept_input(v, i, value=None):
  function accept_input_if_subset (line 36) | def accept_input_if_subset(v, i, value=''):
  function usedInputs (line 49) | def usedInputs(vd):
  function execCommand2 (line 53) | def execCommand2(sheet, cmd, *args, **kwargs):
  function inputPalette (line 57) | def inputPalette(sheet, prompt, items,
  function cmdlist (line 210) | def cmdlist(sheet):
  function inputLongname (line 220) | def inputLongname(sheet):
  function inputLongnameSimple (line 251) | def inputLongnameSimple(sheet):
  function exec_longname (line 258) | def exec_longname(sheet, longname):

FILE: visidata/features/colorbrewer.py
  class PalettesSheet (line 297) | class PalettesSheet(Sheet):
    method iterload (line 309) | def iterload(self):
  function cycle_palette (line 319) | def cycle_palette(obj):
  function set_palette (line 328) | def set_palette(obj, palname, n):

FILE: visidata/features/colorsheet.py
  class ColorSheet (line 5) | class ColorSheet(Sheet):
    method iterload (line 17) | def iterload(self):
    method draw (line 27) | def draw(self, scr):
  function colorsSheet (line 46) | def colorsSheet(vd):

FILE: visidata/features/command_server.py
  class SocketIO (line 13) | class SocketIO(io.RawIOBase):
    method __init__ (line 14) | def __init__(self, sock):
    method read (line 17) | def read(self, sz=-1):
    method seekable (line 21) | def seekable(self):
  function mainloop (line 26) | def mainloop(vd, scr):
  function command_listener (line 34) | def command_listener(vd, addr, port):
  function command_server (line 49) | def command_server(vd, conn):
  function capture_draw_object (line 67) | def capture_draw_object(sheet, topRowIndex=0, nScreenRows=25):

FILE: visidata/features/currency_to_usd.py
  function currency_rates_json (line 23) | def currency_rates_json(date='latest', base='USD'):
  function currency_rates (line 44) | def currency_rates():
  function currency_multiplier (line 48) | def currency_multiplier(src_currency, dest_currency):
  function USD (line 60) | def USD(s):

FILE: visidata/features/customdate.py
  function customdate (line 7) | def customdate(sheet, fmtstr):

FILE: visidata/features/dedupe.py
  function gen_identify_duplicates (line 30) | def gen_identify_duplicates(sheet):
  function select_duplicate_rows (line 59) | def select_duplicate_rows(sheet, duplicates=True):
  function dedupe_rows (line 84) | def dedupe_rows(sheet, suffix='_deduped'):

FILE: visidata/features/describe.py
  function isError (line 12) | def isError(col, row):
  class DescribeColumn (line 23) | class DescribeColumn(Column):
    method __init__ (line 24) | def __init__(self, name, **kwargs):
  class DescribeSheet (line 30) | class DescribeSheet(ColumnsSheet):
    method loader (line 57) | def loader(self):
    method reloadColumn (line 70) | def reloadColumn(self, srccol):
    method calcStatistic (line 99) | def calcStatistic(self, d, func, *args, **kwargs):
    method openCell (line 104) | def openCell(self, col, row):

FILE: visidata/features/expand_cols.py
  function getSampleRows (line 10) | def getSampleRows(sheet):
  function expandCols (line 25) | def expandCols(sheet, cols, rows=None, depth=0):
  function _createExpandedColumns (line 38) | def _createExpandedColumns(sampleValue, col, rows):
  function _ (line 44) | def _(sampleValue, col, vals):
  function _createExpandedColumnsNamedTuple (line 64) | def _createExpandedColumnsNamedTuple(col, val):
  function _ (line 72) | def _(sampleValue, col, vals):
  function expand (line 95) | def expand(col, rows):
  class ExpandedColumn (line 120) | class ExpandedColumn(WritableColumn):
    method calcValue (line 121) | def calcValue(self, row):
    method setValue (line 124) | def setValue(self, row, value, setModified=True):
  function contract_cols (line 132) | def contract_cols(sheet, cols, depth=1):  # depth == 0 means contract al...
  function expand_cols_deep (line 150) | def expand_cols_deep(sheet, cols, rows=None, depth=0):  # depth == 0 mea...
  function contract_source_cols (line 155) | def contract_source_cols(sheet, cols):
  class ColumnGroup (line 166) | class ColumnGroup(Column):
    method calcValue (line 167) | def calcValue(self, row):
    method expand (line 170) | def expand(self, rows):

FILE: visidata/features/fill.py
  function fillNullValues (line 6) | def fillNullValues(vd, col, rows):

FILE: visidata/features/freeze.py
  function resetCache (line 7) | def resetCache(col):
  function freeze_col (line 13) | def freeze_col(sheet, col):
  class StaticSheet (line 34) | class StaticSheet(Sheet):
    method __init__ (line 36) | def __init__(self, source):
    method resetCols (line 39) | def resetCols(self):
    method iterload (line 49) | def iterload(self):
  function setcol_freeze (line 64) | def setcol_freeze(sheet, unfrozen):  #2660  Contributed by @midichef

FILE: visidata/features/go_col.py
  function nextColRegex (line 7) | def nextColRegex(sheet, colregex):
  function nextColName (line 18) | def nextColName(sheet, show_cells=True):

FILE: visidata/features/graph_seaborn.py
  function plot_seaborn (line 10) | def plot_seaborn(vd, rows, xcols, ycols):
  function ext_plot_seaborn (line 17) | def ext_plot_seaborn(vd, rows, xcols, ycols):

FILE: visidata/features/graph_zoom_y.py
  function zoom_all_y (line 6) | def zoom_all_y(sheet):

FILE: visidata/features/hint_types.py
  function hint_type_int (line 4) | def hint_type_int(sheet):
  function hint_type_float (line 12) | def hint_type_float(sheet):

FILE: visidata/features/hlsearch.py
  function highlight_chunks (line 16) | def highlight_chunks(sheet, chunks, hp, hoffset, colwidth, notewidth, ca...
  function setHighlightRegex (line 69) | def setHighlightRegex(sheet, r, cols=[]):
  function highlight_input (line 84) | def highlight_input(sheet, cols=[]):
  function clear_search (line 92) | def clear_search(sheet):

FILE: visidata/features/incr.py
  function numrange (line 8) | def numrange(vd, n, step=1):
  function test_numrange (line 14) | def test_numrange(vd=None):
  function num (line 19) | def num(vd, *args):

FILE: visidata/features/join.py
  function ensureLoaded (line 12) | def ensureLoaded(vd, sheets):
  function _appendRowsAfterLoading (line 21) | def _appendRowsAfterLoading(joinsheet, origsheets):
  function join_sheets_cols (line 49) | def join_sheets_cols(vd, cols, jointype:str=''):
  function openJoin (line 63) | def openJoin(sheet, others, jointype=''):
  function joinkey (line 115) | def joinkey(sheetKeyCols, row):
  function groupRowsByKey (line 119) | def groupRowsByKey(sheets:dict, rowsBySheetKey, rowsByKey):
  class JoinKeyColumn (line 144) | class JoinKeyColumn(WritableColumn):
    method __init__ (line 145) | def __init__(self, name='', keycols=None, **kwargs):
    method calcValue (line 149) | def calcValue(self, row):
    method putValue (line 159) | def putValue(self, row, value):
    method recalc (line 164) | def recalc(self, sheet=None):
  class MergeColumn (line 170) | class MergeColumn(WritableColumn):
    method calcValue (line 172) | def calcValue(self, row):
    method putValue (line 180) | def putValue(self, row, value):
    method isDiff (line 185) | def isDiff(self, row, value):
  class JoinSheet (line 197) | class JoinSheet(Sheet):
    method loader (line 205) | def loader(self):
  class ExtendedColumn (line 271) | class ExtendedColumn(WritableColumn):
    method calcValue (line 272) | def calcValue(self, row):
    method putValue (line 278) | def putValue(self, row, value):
  function ExtendedSheet_reload (line 288) | def ExtendedSheet_reload(self, sheets):
  class ConcatColumn (line 330) | class ConcatColumn(WritableColumn):
    method getColBySheet (line 332) | def getColBySheet(self, s):
    method calcValue (line 335) | def calcValue(self, row):
    method setValue (line 341) | def setValue(self, row, v):
  class ConcatSheet (line 351) | class ConcatSheet(Sheet):
    method iterload (line 354) | def iterload(self):
  function inputJointype (line 379) | def inputJointype(vd):

FILE: visidata/features/known_cols.py
  function afterLoad (line 16) | def afterLoad(sheet):

FILE: visidata/features/layout.py
  function setWidth (line 4) | def setWidth(self, w):
  function toggleWidth (line 12) | def toggleWidth(self, width):
  function toggleMultiline (line 21) | def toggleMultiline(self):
  function unhide_cols (line 28) | def unhide_cols(vd, cols, rows):
  function hide_col (line 34) | def hide_col(vd, col):
  function hide_uniform_cols (line 40) | def hide_uniform_cols(sheet):

FILE: visidata/features/melt.py
  class MeltedSheet (line 14) | class MeltedSheet(Sheet):
    method getValueCols (line 19) | def getValueCols(self) -> dict:
    method resetCols (line 45) | def resetCols(self):
    method iterload (line 72) | def iterload(self):
  function openMelt (line 95) | def openMelt(sheet, regex='(.*)'):

FILE: visidata/features/normcol.py
  function normalize_name (line 52) | def normalize_name(name):
  function gen_normalize_names (line 70) | def gen_normalize_names(names):
  function normalize_column_names (line 91) | def normalize_column_names(sheet):

FILE: visidata/features/open_syspaste.py
  function open_syspaste (line 9) | def open_syspaste(sheet, filetype='tsv'):

FILE: visidata/features/ping.py
  function new_ping (line 11) | def new_ping(vd, p):
  function makePingStats (line 18) | def makePingStats(ip):
  class PingStatsSheet (line 22) | class PingStatsSheet(Sheet):
    method loader (line 37) | def loader(self):
  function PingColumn (line 44) | def PingColumn(name, ip):
  class PingSheet (line 48) | class PingSheet(Sheet):
    method __init__ (line 50) | def __init__(self, *names, source=None, **kwargs):
    method ping_response (line 54) | def ping_response(self, row, ip, data):
    method traceroute_response (line 61) | def traceroute_response(self, ip, data):
    method ping_error (line 76) | def ping_error(self, ip, data):
    method update_traces (line 81) | def update_traces(self, row, ip):
    method send_trace (line 96) | def send_trace(self, ip, n):
    method iterload (line 111) | def iterload(self):

FILE: visidata/features/procmgr.py
  function new_top (line 5) | def new_top(vd, p):
  class CPUStatsSheet (line 9) | class CPUStatsSheet(Sheet):
    method iterload (line 15) | def iterload(self):
  class MemStatsSheet (line 32) | class MemStatsSheet(Sheet):
    method iterload (line 42) | def iterload(self):
  class UsefulProcessesSheet (line 64) | class UsefulProcessesSheet(Sheet):
    method iterload (line 77) | def iterload(self):
  class ProcessesSheet (line 83) | class ProcessesSheet(Sheet):
    method iterload (line 128) | def iterload(self):
  class RlimitsSheet (line 144) | class RlimitsSheet(Sheet):
    method soft (line 151) | def soft(self, r):
    method hard (line 153) | def hard(self, r):
    method set_soft (line 155) | def set_soft(self, r, v):
    method set_hard (line 157) | def set_hard(self, r, v):
    method iterload (line 160) | def iterload(self):
  function cpuStats (line 168) | def cpuStats(vd):
  function memStats (line 172) | def memStats(vd):
  function processes (line 176) | def processes(vd):
  function chooseSignal (line 185) | def chooseSignal(vd):

FILE: visidata/features/pypkg.py
  class PythonPackagesSheet (line 6) | class PythonPackagesSheet(PythonSheet):
    method reload (line 20) | def reload(self):
    method openRow (line 30) | def openRow(self, row):

FILE: visidata/features/rank.py
  class RankAggregator (line 6) | class RankAggregator(ListAggregator):
    method aggregate (line 11) | def aggregate(self, col, rows) -> [int]:
    method aggregate_list (line 14) | def aggregate_list(self, col, rows) -> [int]:
    method rank (line 19) | def rank(self, col, rows):
  function rank_sorted_iterable (line 55) | def rank_sorted_iterable(vals_sorted) -> [int]:
  function addcol_sheetrank (line 68) | def addcol_sheetrank(sheet, rows):

FILE: visidata/features/regex.py
  function help_regex (line 9) | def help_regex(vd):
  function makeRegexSplitter (line 16) | def makeRegexSplitter(vd, regex, origcol):
  function makeRegexMatcher (line 20) | def makeRegexMatcher(vd, regex, origcol):
  function RegexColumn (line 31) | def RegexColumn(vs, regexMaker, origcol, regexstr):
  function addRegexColumns (line 41) | def addRegexColumns(vs, regexMaker, origcol, regexstr):
  function regexTransform (line 78) | def regexTransform(vd, origcol, before='', after=''):
  function parse_sed_transform (line 83) | def parse_sed_transform(vd, instr):
  function indexWithEscape (line 91) | def indexWithEscape(s, char, escape_char='\\'):
  function setValuesFromRegex (line 105) | def setValuesFromRegex(sheet, cols, rows, before='', after=''):
  function inputRegex (line 117) | def inputRegex(vd, prompt, type='regex', **kwargs):
  function inputRegexSubst (line 123) | def inputRegexSubst(vd, prompt):

FILE: visidata/features/reload_every.py
  function reload_every (line 9) | def reload_every(sheet, seconds:int):
  function reload_modified (line 20) | def reload_modified(sheet):
  function reload_rows (line 37) | def reload_rows(self):

FILE: visidata/features/rename_col_cascade.py
  class Renamer (line 8) | class Renamer(ast.NodeTransformer):
    method __init__ (line 9) | def __init__(self, find, replace):
    method visit_Name (line 13) | def visit_Name(self, node):
  function setName (line 21) | def setName(col, newname):

FILE: visidata/features/repeat.py
  function prevCmdlogRow (line 5) | def prevCmdlogRow(vd):
  function repeat_last (line 13) | def repeat_last(sheet, cmdrow):
  function repeat_for_n (line 19) | def repeat_for_n(sheet, cmdrow, n=1):
  function repeat_for_selected (line 26) | def repeat_for_selected(sheet, cmdrow):

FILE: visidata/features/repl.py
  class _LazyNamespace (line 20) | class _LazyNamespace(dict):
    method __init__ (line 22) | def __init__(self, lcm):
    method __getitem__ (line 28) | def __getitem__(self, k):
    method __contains__ (line 35) | def __contains__(self, k):
  function openRepl (line 42) | def openRepl(vd):

FILE: visidata/features/replay_bulk.py
  function replayOne (line 13) | def replayOne(vd, r):
  function replay_reset (line 18) | def replay_reset(vs):  # noqa: ARG001
  function replay_end (line 31) | def replay_end(vs):  # noqa: ARG001
  function printStatus (line 39) | def printStatus(vd, *args, priority=0, source=None):
  function replay_output (line 52) | def replay_output(vs):
  function allow_error (line 62) | def allow_error(vs, pattern:str):  # noqa: ARG001
  function replay_exit (line 68) | def replay_exit(vs):  # noqa: ARG001

FILE: visidata/features/scroll_context.py
  function checkCursor (line 25) | def checkCursor(sheet):
  function toggle_scrollfix (line 48) | def toggle_scrollfix(sheet):

FILE: visidata/features/select_equal_selected.py
  function select_equal_selected (line 6) | def select_equal_selected(sheet, col):

FILE: visidata/features/setcol_fake.py
  function addFakerProviders (line 11) | def addFakerProviders(fake, providers):
  function setValuesFromFaker (line 37) | def setValuesFromFaker(col, faketype, rows):

FILE: visidata/features/slide.py
  function slide_col (line 7) | def slide_col(sheet, colidx, newcolidx):
  function slide_keycol (line 12) | def slide_keycol(sheet, fromKeyColIdx, toKeyColIdx):
  function slide_row (line 18) | def slide_row(sheet, rowidx, newcolidx):
  function moveKeyCol (line 23) | def moveKeyCol(sheet, fromKeyColIdx, toKeyColIdx):
  function moveVisibleCol (line 43) | def moveVisibleCol(sheet, fromVisColIdx, toVisColIdx):
  function make_tester (line 104) | def make_tester(setup_vdx):
  function test_slide_keycol_1 (line 116) | def test_slide_keycol_1(vd):
  function test_slide_leftmost (line 141) | def test_slide_leftmost(vd):

FILE: visidata/features/sparkline.py
  function sparkline (line 12) | def sparkline(*values):
  function addcol_sparkline (line 38) | def addcol_sparkline(sheet, sourceCols):

FILE: visidata/features/status_source.py
  function getStatusSource (line 7) | def getStatusSource(vd) -> str:

FILE: visidata/features/sysedit.py
  function syseditCells (line 6) | def syseditCells(sheet, cols, rows, filetype=None):
  function syseditCells_async (line 13) | def syseditCells_async(sheet, cols, rows, filetype=None):

FILE: visidata/features/sysopen_mailcap.py
  function run_mailcap (line 19) | def run_mailcap(sheet, p, key='view'):

FILE: visidata/features/term_extras.py
  function ansi (line 7) | def ansi(*args):
  function set_titlebar (line 12) | def set_titlebar(vd, title:str):

FILE: visidata/features/transpose.py
  class TransposeSheet (line 5) | class TransposeSheet(Sheet):
    method beforeLoad (line 6) | def beforeLoad(self):
    method loader (line 15) | def loader(self):

FILE: visidata/features/type_ipaddr.py
  function isSupernet (line 14) | def isSupernet(cell, network, isNull):
  function selectSupernets (line 31) | def selectSupernets(col, ip):

FILE: visidata/features/type_url.py
  function displayer_url (line 5) | def displayer_url(self, dw:DisplayWrapper, width=None):

FILE: visidata/features/unfurl.py
  class UnfurledSheet (line 17) | class UnfurledSheet(Sheet):
    method resetCols (line 19) | def resetCols(self):
    method iterload (line 32) | def iterload(self):
  function unfurl_col (line 65) | def unfurl_col(sheet, col):

FILE: visidata/features/window.py
  function window (line 7) | def window(sheet, before:int=0, after:int=0):
  function window (line 16) | def window(col, before:int=0, after:int=0):
  class WindowColumn (line 22) | class WindowColumn(Column):
    method getValue (line 23) | def getValue(self, row):
    method _calcWindowRows (line 27) | def _calcWindowRows(self, outvals):
    method windowrows (line 32) | def windowrows(self):
    method __getstate__ (line 39) | def __getstate__(self):
    method __setstate__ (line 46) | def __setstate__(self, r):
  function addcol_window (line 51) | def addcol_window(sheet, curcol):
  function select_around (line 59) | def select_around(sheet, n):

FILE: visidata/form.py
  function open_mnu (line 6) | def open_mnu(vd, p):
  class FormSheet (line 12) | class FormSheet(VisiDataMetaSheet):
  function replayCommand (line 16) | def replayCommand(vd, longname, input=None, sheet=None, col='', row=''):
  class FormCanvas (line 20) | class FormCanvas(BaseSheet):
    method onPressed (line 24) | def onPressed(self, r):
    method onReleased (line 28) | def onReleased(self, r):
    method reload (line 32) | def reload(self):
    method draw (line 35) | def draw(self, scr):
    method run (line 60) | def run(self, scr):
  function confirm (line 104) | def confirm(vd, prompt, exc=EscapeException):

FILE: visidata/freqtbl.py
  function valueNames (line 14) | def valueNames(vd, discrete_vals, numeric_vals):
  class HistogramColumn (line 21) | class HistogramColumn(Column):
    method calcValue (line 23) | def calcValue(col, row):
    method updateLargest (line 28) | def updateLargest(col, row):
  function makeFreqTable (line 32) | def makeFreqTable(sheet, *groupByCols):
  class FreqTableSheet (line 41) | class FreqTableSheet(PivotSheet):
    method groupByColsName (line 61) | def groupByColsName(self):
    method selectRow (line 64) | def selectRow(self, row):
    method unselectRow (line 69) | def unselectRow(self, row):
    method addUndoSelection (line 73) | def addUndoSelection(self):
    method select (line 82) | def select(self, rows, status=True, progress=True, add_undo=True):
    method unselect (line 87) | def unselect(self, rows, status=True, progress=True, add_undo=True):
    method toggle (line 92) | def toggle(self, rows, add_undo=True):
    method select_row (line 98) | def select_row(self, row, add_undo=True):
    method unselect_row (line 104) | def unselect_row(self, row, add_undo=True):
    method toggle_row (line 110) | def toggle_row(self, row, add_undo=True):
    method resetCols (line 116) | def resetCols(self):
    method loader (line 135) | def loader(self):
    method afterLoad (line 142) | def afterLoad(self):
    method openRow (line 148) | def openRow(self, row):
    method openRows (line 157) | def openRows(self, rows):
    method openCell (line 163) | def openCell(self, col, row):
  class FreqTableSheetSummary (line 167) | class FreqTableSheetSummary(FreqTableSheet):
    method afterLoad (line 169) | def afterLoad(self):
  function makeFreqTableSheetSummary (line 174) | def makeFreqTableSheetSummary(sheet, *groupByCols):
  class FreqTablePreviewSheet (line 182) | class FreqTablePreviewSheet(Sheet):
    method rows (line 184) | def rows(self):
  function exceptRows (line 189) | def exceptRows(sheet, exceptrows):

FILE: visidata/fuzzymatch.py
  function asciiFuzzyIndex (line 78) | def asciiFuzzyIndex(target, pattern):
  function charClassOfAscii (line 97) | def charClassOfAscii(char):
  function bonusFor (line 111) | def bonusFor(prevClass, class_):
  function debugV2 (line 137) | def debugV2(T, pattern, F, lastIdx, H, C):
  class MatchResult (line 167) | class MatchResult:
  function _fuzzymatch (line 184) | def _fuzzymatch(target: str, pattern: str) -> MatchResult:
  function _format_match (line 359) | def _format_match(s, positions):
  function fuzzymatch (line 377) | def fuzzymatch(vd, haystack:"list[dict[str, str]]", needles:"list[str]) ...
  function test_fuzzymatch (line 406) | def test_fuzzymatch(vd):

FILE: visidata/graph.py
  function numericCols (line 17) | def numericCols(vd, cols):
  class InvertedCanvas (line 21) | class InvertedCanvas(Canvas):
    method render_async (line 23) | def render_async(self):
    method fixPoint (line 26) | def fixPoint(self, plotterPoint, canvasPoint):
    method rowsWithin (line 32) | def rowsWithin(self, plotter_bbox):
    method zoomTo (line 35) | def zoomTo(self, bbox):
    method scaleY (line 41) | def scaleY(self, canvasY) -> int:
    method unscaleY (line 45) | def unscaleY(self, plotterY_inverted):
    method canvasMouse (line 50) | def canvasMouse(self):
    method calcTopCursorY (line 56) | def calcTopCursorY(self):
    method calcBottomCursorY (line 60) | def calcBottomCursorY(self):
    method startCursor (line 66) | def startCursor(self):
  class GraphSheet (line 74) | class GraphSheet(InvertedCanvas):
    method __init__ (line 77) | def __init__(self, *names, **kwargs):
    method resetCanvasDimensions (line 89) | def resetCanvasDimensions(self, windowHeight, windowWidth):
    method reload (line 95) | def reload(self):
    method draw (line 129) | def draw(self, scr):
    method draw_reflines (line 142) | def draw_reflines(self, scr):
    method resetBounds (line 162) | def resetBounds(self, refresh=True):
    method moveToRow (line 168) | def moveToRow(self, rowstr):
    method plot_elements (line 174) | def plot_elements(self, invert_y=True):
    method plot_reflines (line 178) | def plot_reflines(self):
    method moveToCol (line 211) | def moveToCol(self, colstr):
    method formatX (line 217) | def formatX(self, amt):
    method formatY (line 220) | def formatY(self, amt):
    method formatXLabel (line 224) | def formatXLabel(self, amt):
    method formatYLabel (line 237) | def formatYLabel(self, amt):
    method parseX (line 244) | def parseX(self, txt):
    method parseY (line 247) | def parseY(self, txt):
    method add_y_axis_label (line 250) | def add_y_axis_label(self, frac):
    method add_x_axis_label (line 261) | def add_x_axis_label(self, frac):
    method createLabels (line 284) | def createLabels(self):
    method rowsWithin (line 309) | def rowsWithin(self, plotter_bbox):
    method draw_refline_x (line 314) | def draw_refline_x(self):
    method draw_refline_y (line 327) | def draw_refline_y(self):
    method erase_refline_x (line 336) | def erase_refline_x(self):
    method erase_refline_y (line 350) | def erase_refline_y(self):
  function format_input_value (line 363) | def format_input_value(val, type):
  function set_y (line 391) | def set_y(sheet, s):
  function set_x (line 397) | def set_x(sheet, s):
  function reload (line 413) | def reload(sheet):

FILE: visidata/guide.py
  function addGuide (line 84) | def addGuide(vd, name):
  class GuideIndex (line 90) | class GuideIndex(Sheet):
    method iterload (line 102) | def iterload(self):
    method openRow (line 112) | def openRow(self, row):
  class OptionHelpGetter (line 116) | class OptionHelpGetter:
    method __getattr__ (line 118) | def __getattr__(self, optname):
  class CommandHelpGetter (line 123) | class CommandHelpGetter:
    method __init__ (line 125) | def __init__(self, cls):
    method __getattr__ (line 130) | def __getattr__(self, k):
    method __getitem__ (line 133) | def __getitem__(self, k):
  class GuideSheet (line 157) | class GuideSheet(Sheet):
    method iterload (line 167) | def iterload(self):
  function getGuide (line 200) | def getGuide(vd, name): # -> GuideSheet()
  function inputKeys (line 208) | def inputKeys(vd, prompt):
  function getCommandInfo (line 217) | def getCommandInfo(sheet, keys):

FILE: visidata/help.py
  function wantsHelp (line 22) | def wantsHelp(vd, feat):
  function hint_basichelp (line 27) | def hint_basichelp(sheet):
  function iterMenuPaths (line 32) | def iterMenuPaths(vd, item=None, menupath=[]):
  function menuPathsByLongname (line 48) | def menuPathsByLongname(vd):
  class HelpSheet (line 53) | class HelpSheet(MetaSheet):
    method iterload (line 72) | def iterload(self):
    method revbinds (line 92) | def revbinds(self):
  class HelpPane (line 101) | class HelpPane:
    method __init__ (line 102) | def __init__(self, name):
    method width (line 110) | def width(self):
    method height (line 114) | def height(self):
    method draw (line 117) | def draw(self, scr, x=None, y=None, **kwargs):
  function getHelpPane (line 163) | def getHelpPane(vd, name, module='visidata') -> HelpPane:
  function openManPage (line 178) | def openManPage(vd):

FILE: visidata/hint.py
  function prevHints (line 7) | def prevHints(sheet):
  function getHint (line 12) | def getHint(sheet, *args, **kwargs) -> str:

FILE: visidata/indexsheet.py
  class IndexSheet (line 4) | class IndexSheet(Sheet):
    method newRow (line 24) | def newRow(self):
    method openRow (line 27) | def openRow(self, row):
    method getSheet (line 30) | def getSheet(self, k):
    method addRow (line 35) | def addRow(self, sheet, **kwargs):
    method reloadSheets (line 41) | def reloadSheets(self, sheets):
  class SheetsSheet (line 46) | class SheetsSheet(IndexSheet):
    method reload (line 63) | def reload(self):
    method sort (line 66) | def sort(self):
  class GlobalSheetsSheet (line 70) | class GlobalSheetsSheet(SheetsSheet):  #1620
    method sort (line 71) | def sort(self):
  function sheetsSheet (line 76) | def sheetsSheet(vd):
  function allSheetsSheet (line 81) | def allSheetsSheet(vd):
  function nextRow (line 87) | def nextRow(sheet, n=1):

FILE: visidata/input_history.py
  function addInputHistory (line 9) | def addInputHistory(vd, input:str, type:str=''):
  function processInputHistory (line 16) | def processInputHistory(vd, input:str, type:str=''):
  class InputHistorySheet (line 31) | class InputHistorySheet(Sheet):
    method iterload (line 38) | def iterload(self):
  function run (line 44) | def run(vd, *args, **kwargs):
  function inputHistorySheet (line 51) | def inputHistorySheet(vd):

FILE: visidata/keys.py
  function prettykeys (line 114) | def prettykeys(vd, key:str) -> str:

FILE: visidata/loaders/_pandas.py
  function open_pandas (line 6) | def open_pandas(vd, p):
  function open_dta (line 10) | def open_dta(vd, p):
  function save_dta (line 22) | def save_dta(vd, p, *sheets):
  class DataFrameAdapter (line 55) | class DataFrameAdapter:
    method __init__ (line 56) | def __init__(self, df):
    method __len__ (line 63) | def __len__(self):
    method __getitem__ (line 68) | def __getitem__(self, k):
    method __getattr__ (line 73) | def __getattr__(self, k):
  class PandasSheet (line 79) | class PandasSheet(Sheet):
    method dtype_to_type (line 93) | def dtype_to_type(self, dtype):
    method read_tsv (line 109) | def read_tsv(self, path, **kwargs):
    method df (line 115) | def df(self):
    method df (line 120) | def df(self, val):
    method getValue (line 126) | def getValue(self, col, row):
    method setValue (line 130) | def setValue(self, col, row, val):
    method reload (line 147) | def reload(self):
    method sort (line 204) | def sort(self):
    method _checkSelectedIndex (line 213) | def _checkSelectedIndex(self):
    method rowid (line 221) | def rowid(self, row):
    method isSelected (line 228) | def isSelected(self, row):
    method selectRow (line 234) | def selectRow(self, row):
    method unselectRow (line 239) | def unselectRow(self, row):
    method nSelectedRows (line 246) | def nSelectedRows(self):
    method selectedRows (line 251) | def selectedRows(self):
    method select (line 257) | def select(self, rows, status=True, progress=True):
    method unselect (line 263) | def unselect(self, rows, status=True, progress=True):
    method clearSelected (line 268) | def clearSelected(self):
    method selectByIndex (line 272) | def selectByIndex(self, start=None, end=None):
    method unselectByIndex (line 276) | def unselectByIndex(self, start=None, end=None):
    method toggleByIndex (line 280) | def toggleByIndex(self, start=None, end=None):
    method _selectByILoc (line 285) | def _selectByILoc(self, mask, selected=True):
    method selectByRegex (line 290) | def selectByRegex(self, regex, columns, unselect=False):
    method addUndoSelection (line 307) | def addUndoSelection(self):
    method nRows (line 311) | def nRows(self):
    method newRows (line 316) | def newRows(self, n):
    method addRows (line 328) | def addRows(self, rows, index=None, undo=True):
    method _deleteRows (line 340) | def _deleteRows(self, which):
    method addRow (line 346) | def addRow(self, row, index=None):
    method delete_row (line 350) | def delete_row(self, rowidx):
    method deleteBy (line 364) | def deleteBy(self, by):
    method deleteSelected (line 377) | def deleteSelected(self):
  function view_pandas (line 383) | def view_pandas(vd, df):

FILE: visidata/loaders/api_airtable.py
  function guessurl_airtable (line 12) | def guessurl_airtable(vd, p, response):
  function open_airtable (line 19) | def open_airtable(vd, p):
  class AirtableSheet (line 38) | class AirtableSheet(Sheet):
    method iterload (line 50) | def iterload(self):
    method newRow (line 65) | def newRow(self):
  function api (line 70) | def api(self):

FILE: visidata/loaders/api_matrix.py
  function openhttp_matrix (line 20) | def openhttp_matrix(vd, p):
  class MatrixRoomsSheet (line 40) | class MatrixRoomsSheet(Sheet):
    method iterload (line 41) | def iterload(self):
  class MatrixSheet (line 45) | class MatrixSheet(Sheet):
    method sourcename (line 60) | def sourcename(self):
    method reload (line 68) | def reload(self):
    method add_room (line 94) | def add_room(self, room):
    method get_room_messages (line 100) | def get_room_messages(self, room):
    method addRow (line 111) | def addRow(self, r, **kwargs):
    method global_event (line 117) | def global_event(self, chunk):
    method room_event (line 120) | def room_event(self, room, chunk):
    method add_message (line 138) | def add_message(self, text):
    method openRow (line 141) | def openRow(self, row):

FILE: visidata/loaders/api_reddit.py
  function open_reddit (line 22) | def open_reddit(vd, p):
  function reddit (line 40) | def reddit(vd):
  function hiddenCols (line 122) | def hiddenCols(hidden_attrs):
  class SubredditSheet (line 132) | class SubredditSheet(Sheet):
    method iterload (line 148) | def iterload(self):
    method openRow (line 161) | def openRow(self, row):
    method openRows (line 164) | def openRows(self, rows):
  class RedditorsSheet (line 169) | class RedditorsSheet(Sheet):
    method iterload (line 181) | def iterload(self):
    method openRow (line 188) | def openRow(self, row):
    method openRows (line 191) | def openRows(self, rows):
  class RedditSubmissions (line 196) | class RedditSubmissions(Sheet):
    method iterload (line 219) | def iterload(self):
    method openRow (line 225) | def openRow(self, row):
  class RedditComments (line 229) | class RedditComments(Sheet):
    method iterload (line 246) | def iterload(self):
    method openRow (line 249) | def openRow(self, row):
  class RedditGuide (line 253) | class RedditGuide(RedditSubmissions):
  function addRowsFromQuery (line 276) | def addRowsFromQuery(sheet, q):
  function addRowsFromQuery (line 283) | def addRowsFromQuery(sheet, q):
  function sysopen_subreddits (line 289) | def sysopen_subreddits(vd, *subreddits):

FILE: visidata/loaders/api_zulip.py
  function open_zulip (line 14) | def open_zulip(vd, p):
  function z_rpc (line 35) | def z_rpc(vd, r, result_field_name=None):
  function allStreams (line 43) | def allStreams(vd):
  function subscribedStreams (line 48) | def subscribedStreams(vd):
  function allMessages (line 53) | def allMessages(vd):
  function parseColumns (line 58) | def parseColumns(vd, fieldlist):
  class ZulipAPISheet (line 70) | class ZulipAPISheet(Sheet):
    method iterload (line 77) | def iterload(self):
    method addRow (line 91) | def addRow(self, r, **kwargs):
  class ZulipStreamsSheet (line 95) | class ZulipStreamsSheet(ZulipAPISheet):
    method openRow (line 104) | def openRow(self, r):
    method openCell (line 107) | def openCell(self, c, r):
  class ZulipTopicsSheet (line 114) | class ZulipTopicsSheet(ZulipAPISheet):
    method openRow (line 117) | def openRow(self, r):
  class ZulipMembersSheet (line 121) | class ZulipMembersSheet(ZulipAPISheet):
    method openRow (line 127) | def openRow(self, r):
  class ZulipMessagesSheet (line 131) | class ZulipMessagesSheet(Sheet):
    method reload (line 155) | def reload(self):
    method get_channel_name (line 181) | def get_channel_name(self, r):
    method update_message (line 188) | def update_message(self, msgid, content):
    method openRow (line 195) | def openRow(self, r):
    method received_event (line 200) | def received_event(self, event):
    method reply_message (line 204) | def reply_message(self, msg, row):
    method send_message (line 212) | def send_message(self, msg, subject, dest, msgtype='stream'):

FILE: visidata/loaders/archive.py
  function guess_zip (line 13) | def guess_zip(vd, p):
  function guess_tar (line 18) | def guess_tar(vd, p):
  function open_zip (line 26) | def open_zip(vd, p):
  function open_tar (line 30) | def open_tar(vd, p):
  class ZipSheet (line 39) | class ZipSheet(Sheet):
    method openZipFile (line 68) | def openZipFile(self, fp, *args, **kwargs):
    method openRow (line 78) | def openRow(self, row):
    method extract (line 83) | def extract(self, *rows, path=None):
    method sysopen_row (line 92) | def sysopen_row(self, row):
    method extract_async (line 100) | def extract_async(self, *rows, path=None):
    method zfp (line 107) | def zfp(self):
    method iterload (line 124) | def iterload(self):
  class TarSheet (line 147) | class TarSheet(Sheet):
    method openRow (line 162) | def openRow(self, fi):
    method iterload (line 166) | def iterload(self):

FILE: visidata/loaders/arrow.py
  function open_arrow (line 8) | def open_arrow(vd, p):
  function open_arrows (line 14) | def open_arrows(vd, p):
  function arrow_to_vdtype (line 19) | def arrow_to_vdtype(t):
  class ArrowSheet (line 59) | class ArrowSheet(Sheet):
    method iterload (line 60) | def iterload(self):
  function save_arrow (line 83) | def save_arrow(vd, p, sheet, streaming=False):
  function save_arrows (line 125) | def save_arrows(vd, p, sheet):

FILE: visidata/loaders/claude.py
  function _ts (line 18) | def _ts(s):
  function _content_text (line 30) | def _content_text(msg):
  function open_claude (line 51) | def open_claude(vd, p):
  class ClaudeProjectsSheet (line 59) | class ClaudeProjectsSheet(Sheet):
    method iterload (line 67) | def iterload(self):
    method openRow (line 74) | def openRow(self, row):
  function _session_meta (line 78) | def _session_meta(p):
  class ClaudeSessionsSheet (line 102) | class ClaudeSessionsSheet(Sheet):
    method iterload (line 112) | def iterload(self):
    method openRow (line 117) | def openRow(self, row):
  class ClaudeSessionSheet (line 122) | class ClaudeSessionSheet(Sheet):
    method iterload (line 132) | def iterload(self):

FILE: visidata/loaders/conll.py
  function open_conll (line 6) | def open_conll(vd, p):
  function open_conllu (line 11) | def open_conllu(vd, p):
  class ConllSheet (line 15) | class ConllSheet(TableSheet):
    method iterload (line 38) | def iterload(self):

FILE: visidata/loaders/csv.py
  function guess_csv_delimiter (line 16) | def guess_csv_delimiter(vd, p):
  function guess_csv (line 23) | def guess_csv(vd, p):
  function open_csv (line 45) | def open_csv(vd, p):
  function removeNulls (line 48) | def removeNulls(fp):
  class CsvSheet (line 52) | class CsvSheet(SequenceSheet):
    method iterload (line 55) | def iterload(self):
  function save_csv (line 83) | def save_csv(vd, p, sheet):

FILE: visidata/loaders/eml.py
  function open_eml (line 6) | def open_eml(vd, p):
  class EmailSheet (line 11) | class EmailSheet(TableSheet):
    method iterload (line 18) | def iterload(self):
  function extract_part (line 25) | def extract_part(sheet, givenpath, part):
  function extract_parts (line 34) | def extract_parts(sheet, givenpath, *parts):

FILE: visidata/loaders/f5log.py
  class hexint (line 38) | class hexint(int):
    method __new__ (line 39) | def __new__(cls, value, *args, **kwargs):
    method __str__ (line 42) | def __str__(self):
  class delta_t (line 46) | class delta_t(int):
    method __new__ (line 47) | def __new__(cls, value, *args, **kwargs):
  class F5LogSheet (line 84) | class F5LogSheet(Sheet):
    class F5LogRow (line 85) | class F5LogRow:
      method __init__ (line 86) | def __init__(
      method __getattr__ (line 114) | def __getattr__(self, item):
    method colorizeMonitors (line 230) | def colorizeMonitors(sheet, col: Column, row: F5LogRow, value):
    method colorizeRows (line 268) | def colorizeRows(sheet, col: Column, row: F5LogRow, value):
    method split_audit_bigip_tmsh_audit (line 280) | def split_audit_bigip_tmsh_audit(msg):
    method split_audit_scriptd_run_script (line 288) | def split_audit_scriptd_run_script(msg):
    method split_audit_mcpd_mcp_error (line 296) | def split_audit_mcpd_mcp_error(msg):
    method split_ltm_pool_mon_status (line 354) | def split_ltm_pool_mon_status(msg):
    method split_ltm_poolnode_mon_abled (line 406) | def split_ltm_poolnode_mon_abled(msg):
    method split_ltm_pool_has_no_avail_mem (line 419) | def split_ltm_pool_has_no_avail_mem(msg):
    method split_ltm_pool_has_avail_mem (line 428) | def split_ltm_pool_has_avail_mem(msg):
    method split_ltm_rule (line 437) | def split_ltm_rule(msg):
    method split_ltm_rule_missing_datagroup (line 472) | def split_ltm_rule_missing_datagroup(msg):
    method split_ltm_cert_expiry (line 494) | def split_ltm_cert_expiry(msg):
    method split_ltm_connection_error (line 513) | def split_ltm_connection_error(msg):
    method split_ltm_virtual_status (line 527) | def split_ltm_virtual_status(msg):
    method split_ltm_virtual_address_status_or_irule_profile_err (line 545) | def split_ltm_virtual_address_status_or_irule_profile_err(msg):
    method split_ltm_ssl_handshake_fail (line 566) | def split_ltm_ssl_handshake_fail(msg):
    method split_ltm_shared_ciphers (line 588) | def split_ltm_shared_ciphers(msg):
    method split_ltm_rst_reason (line 601) | def split_ltm_rst_reason(msg):
    method split_ltm_inet_port_exhaust (line 628) | def split_ltm_inet_port_exhaust(msg):
    method split_ltm_conn_limit_reached (line 645) | def split_ltm_conn_limit_reached(msg):
    method split_ltm_syncookie_threshold (line 670) | def split_ltm_syncookie_threshold(msg):
    method split_ltm_sweeper_active2 (line 688) | def split_ltm_sweeper_active2(msg):
    method split_ltm_sweeper_active3 (line 699) | def split_ltm_sweeper_active3(msg):
    method split_ltm_dns_failed_xfr_rcode (line 709) | def split_ltm_dns_failed_xfr_rcode(msg):
    method split_ltm_dns_failed_rr (line 717) | def split_ltm_dns_failed_rr(msg):
    method split_ltm_dns_failed_xfr (line 725) | def split_ltm_dns_failed_xfr(msg):
    method split_ltm_dns_handling_notify (line 735) | def split_ltm_dns_handling_notify(msg):
    method split_ltm_dns_axfr_succeeded_1f (line 743) | def split_ltm_dns_axfr_succeeded_1f(msg):
    method split_ltm_dns_axfr_succeeded_2c (line 752) | def split_ltm_dns_axfr_succeeded_2c(msg):
    method split_ltm_dns_ignoring_tfer (line 762) | def split_ltm_dns_ignoring_tfer(msg):
    method split_ltm_http_process_state (line 772) | def split_ltm_http_process_state(msg):
    method split_ltm_http_header_exceeded (line 836) | def split_ltm_http_header_exceeded(msg):
    method split_gtm_monitor (line 858) | def split_gtm_monitor(msg):
    method split_gtm_monitor_instance (line 897) | def split_gtm_monitor_instance(msg):
    method split_gtm_syncgroup_change (line 922) | def split_gtm_syncgroup_change(msg):
    method split_gtm_changed_state (line 932) | def split_gtm_changed_state(msg):
    method split_tmm_address_conflict (line 941) | def split_tmm_address_conflict(msg):
    method __init__ (line 1063) | def __init__(self, *args, **kwargs):
    method iterload (line 1082) | def iterload(self):
  function open_f5log (line 1202) | def open_f5log(vd: VisiData, p: Path) -> Sheet:

FILE: visidata/loaders/fec.py
  class DiveSheet (line 50) | class DiveSheet(Sheet):
    method reload (line 53) | def reload(self):
    method openRow (line 112) | def openRow(self, row):
  class FECItemizationSheet (line 129) | class FECItemizationSheet(Sheet):
    method reload (line 135) | def reload(self):
    method set_columns_from_row (line 147) | def set_columns_from_row(self, row):
    method openRow (line 152) | def openRow(self, row):
  class FECScheduleSheet (line 155) | class FECScheduleSheet(Sheet):
    method reload (line 169) | def reload(self):
    method openRow (line 181) | def openRow(self, row):
  class FECFiling (line 192) | class FECFiling(Sheet):
    method reload (line 207) | def reload(self):
    method openRow (line 289) | def openRow(self, row):
  function open_fec (line 293) | def open_fec(vd, p):

FILE: visidata/loaders/fixed_width.py
  function open_fixed (line 10) | def open_fixed(vd, p):
  function getMaxDataWidth (line 14) | def getMaxDataWidth(col, rows):  #2255 need real max width for fixed wid...
  class FixedWidthColumn (line 29) | class FixedWidthColumn(WritableColumn):
    method __init__ (line 30) | def __init__(self, name, i, j, **kwargs):
    method calcValue (line 34) | def calcValue(self, row):
    method putValue (line 37) | def putValue(self, row, value):
  function columnize (line 46) | def columnize(rows, has_header=True):
  class FixedWidthColumnsSheet (line 95) | class FixedWidthColumnsSheet(SequenceSheet):
    method addRow (line 97) | def addRow(self, row, index=None):
    method iterload (line 100) | def iterload(self):
    method setCols (line 120) | def setCols(self, headerlines):
  function save_fixed (line 125) | def save_fixed(vd, p, *vsheets):

FILE: visidata/loaders/frictionless.py
  function open_frictionless (line 4) | def open_frictionless(vd, p):
  class FrictionlessIndexSheet (line 7) | class FrictionlessIndexSheet(IndexSheet):
    method iterload (line 8) | def iterload(self):

FILE: visidata/loaders/geojson.py
  function open_geojson (line 11) | def open_geojson(vd, p):
  class GeoJSONColumn (line 14) | class GeoJSONColumn(WritableColumn):
    method calcValue (line 15) | def calcValue(self, row):
    method putValue (line 18) | def putValue(self, row, val):
  class GeoJSONSheet (line 23) | class GeoJSONSheet(PythonSheet):
    method iterload (line 27) | def iterload(self):
  class GeoJSONMap (line 51) | class GeoJSONMap(InvertedCanvas):
    method reload (line 56) | def reload(self):
    method parse_geometry (line 81) | def parse_geometry(self, row, colour, bbox=None):
  function reduce_coords (line 115) | def reduce_coords(coords, initial):
  function _rowdict (line 120) | def _rowdict(cols, row):
  function save_geojson (line 135) | def save_geojson(vd, p, vs):

FILE: visidata/loaders/google.py
  function _google_creds_fn (line 6) | def _google_creds_fn():
  function google_auth (line 19) | def google_auth(vd, scopes=None):

FILE: visidata/loaders/graphviz.py
  function is_valid (line 7) | def is_valid(v):
  function save_dot (line 16) | def save_dot(vd, p, vs):

FILE: visidata/loaders/grep.py
  function open_grep (line 9) | def open_grep(vd, p):
  function save_grep (line 13) | def save_grep(vd, p, *vsheets):
  function format_row (line 16) | def format_row(rowdict):
  class GrepSheet (line 33) | class GrepSheet(JsonSheet):
    method iterload (line 46) | def iterload(self):
    method afterLoad (line 92) | def afterLoad(self):
  function sysopen_row (line 97) | def sysopen_row(sheet, row):

FILE: visidata/loaders/hdf5.py
  function open_h5 (line 5) | def open_h5(vd, p):
  class Hdf5ObjSheet (line 12) | class Hdf5ObjSheet(Sheet):
    method iterload (line 15) | def iterload(self):
    method openRow (line 68) | def openRow(self, row):
  function _guess_type (line 80) | def _guess_type(fmt):

FILE: visidata/loaders/html.py
  function guess_html (line 13) | def guess_html(vd, p):
  function open_html (line 25) | def open_html(vd, p):
  class HtmlTablesSheet (line 31) | class HtmlTablesSheet(IndexSheet):
    method iterload (line 43) | def iterload(self):
  function is_header (line 59) | def is_header(elem):
  class HtmlLinksSheet (line 68) | class HtmlLinksSheet(Sheet):
    method iterload (line 77) | def iterload(self):
    method openRow (line 84) | def openRow(self, row):
  class HtmlElementsSheet (line 87) | class HtmlElementsSheet(Sheet):
    method iterload (line 92) | def iterload(self):
    method openRow (line 103) | def openRow(self, row):
  class HtmlTableSheet (line 107) | class HtmlTableSheet(Sheet):
    method iterload (line 111) | def iterload(self):
  function save_html (line 213) | def save_html(vd, p, *vsheets):
  function utf8_parser (line 245) | def utf8_parser(vd):
  function HTML (line 252) | def HTML(vd, s):

FILE: visidata/loaders/http.py
  function guessurl_mimetype (line 12) | def guessurl_mimetype(vd, path, response):
  function openurl_http (line 30) | def openurl_http(vd, path, filetype=None):
  function parse_header_links (line 99) | def parse_header_links(link_header):

FILE: visidata/loaders/imap.py
  function openurl_imap (line 7) | def openurl_imap(vd, url, **kwargs):
  class ImapSheet (line 12) | class ImapSheet(TableSheet):
    method iterload (line 26) | def iterload(self):
    method addRow (line 65) | def addRow(self, row, **kwargs):

FILE: visidata/loaders/jrnl.py
  function open_jrnl (line 10) | def open_jrnl(vd, p):
  class JrnlSheet (line 14) | class JrnlSheet(TableSheet):
    method iterload (line 23) | def iterload(self):
  function save_jrnl (line 44) | def save_jrnl(vd, p, *vsheets):

FILE: visidata/loaders/json.py
  function guess_json (line 12) | def guess_json(vd, p):
  function open_jsonobj (line 29) | def open_jsonobj(vd, p):
  function open_jsonl (line 33) | def open_jsonl(vd, p):
  class JsonSheet (line 39) | class JsonSheet(Sheet):
    method resetCols (line 41) | def resetCols(self):
    method iterload (line 45) | def iterload(self):
    method addColumn (line 71) | def addColumn(self, *cols, index=None):
    method addRow (line 76) | def addRow(self, row, index=None):
    method newRow (line 93) | def newRow(self, **fields):
    method openRow (line 96) | def openRow(self, row):
  class _vjsonEncoder (line 103) | class _vjsonEncoder(json.JSONEncoder):
    method default (line 104) | def default(self, obj):
  function get_json_value (line 109) | def get_json_value(vd, col, row):
  function _rowdict (line 120) | def _rowdict(cols, row, keep_nulls=False):
  function encode_json (line 130) | def encode_json(vd, row, cols, enc=_vjsonEncoder(sort_keys=False)):
  function save_json (line 136) | def save_json(vd, p, *vsheets):
  function write_jsonl (line 171) | def write_jsonl(vs, fp):
  function save_jsonl (line 191) | def save_jsonl(vd, p, *vsheets):
  function JSON (line 200) | def JSON(vd, s:str):
  function find_duplicates (line 204) | def find_duplicates(names):

FILE: visidata/loaders/jsonla.py
  function guess_jsonla (line 7) | def guess_jsonla(vd, p):
  function open_jsonla (line 36) | def open_jsonla(vd, p):
  class JsonlArraySheet (line 40) | class JsonlArraySheet(SequenceSheet):
    method iterload (line 42) | def iterload(self):
  function get_jsonla_rows (line 52) | def get_jsonla_rows(sheet, cols):
  class _vjsonEncoder (line 57) | class _vjsonEncoder(json.JSONEncoder):
    method default (line 58) | def default(self, obj):
  function write_jsonla (line 62) | def write_jsonla(vs, fp):
  function save_jsonla (line 74) | def save_jsonla(vd, p, *vsheets):

FILE: visidata/loaders/lsv.py
  function open_lsv (line 9) | def open_lsv(vd, p):
  function save_lsv (line 14) | def save_lsv(vd, p, *vsheets):
  class LsvSheet (line 23) | class LsvSheet(Sheet):
    method addRow (line 24) | def addRow(self, row, **kwargs):
    method iterload (line 32) | def iterload(self):

FILE: visidata/loaders/mailbox.py
  function open_mbox (line 5) | def open_mbox(vd, p):
  function open_maildir (line 10) | def open_maildir(vd, p):
  function open_mmdf (line 14) | def open_mmdf(vd, p):
  function open_babyl (line 18) | def open_babyl(vd, p):
  function open_mh (line 22) | def open_mh(vd, p):
  class MboxSheet (line 26) | class MboxSheet(Sheet):
    method iterload (line 36) | def iterload(self):

FILE: visidata/loaders/markdown.py
  function markdown_link (line 3) | def markdown_link(s, href):
  function markdown_escape (line 9) | def markdown_escape(s, style='orgmode'):
  function markdown_colhdr (line 21) | def markdown_colhdr(col):
  function write_md (line 27) | def write_md(p, *vsheets, md_style='orgmode'):
  function save_md (line 68) | def save_md(vd, p, *sheets):
  function save_jira (line 73) | def save_jira(vd, p, *sheets):

FILE: visidata/loaders/mbtiles.py
  function open_pbf (line 7) | def open_pbf(vd, p):
  function open_mbtiles (line 11) | def open_mbtiles(vd, p):
  function getListDepth (line 14) | def getListDepth(L):
  function getFeatures (line 21) | def getFeatures(tile_data):
  function tilename (line 27) | def tilename(row):
  class MbtilesSheet (line 31) | class MbtilesSheet(Sheet):
    method getTile (line 38) | def getTile(self, zoom_level, tile_col, tile_row):
    method iterload (line 50) | def iterload(self):
    method getPlot (line 58) | def getPlot(self, *rows):
    method openRow (line 67) | def openRow(self, row):
  class PbfSheet (line 72) | class PbfSheet(Sheet):
    method iterload (line 81) | def iterload(self):
  class PbfCanvas (line 91) | class PbfCanvas(InvertedCanvas):
    method iterpolylines (line 93) | def iterpolylines(self, r):
    method reload (line 118) | def reload(self):

FILE: visidata/loaders/msgpack.py
  function open_msgpack (line 5) | def open_msgpack(vd, p):
  class MsgpackSheet (line 12) | class MsgpackSheet(JsonSheet):
    method iterload (line 13) | def iterload(self):

FILE: visidata/loaders/mysql.py
  function codeToType (line 6) | def codeToType(type_code, colname):
  function openurl_mysql (line 24) | def openurl_mysql(vd, url, filetype=None):
  class SQL (line 30) | class SQL:
    method __init__ (line 31) | def __init__(self, url):
    method cur (line 35) | def cur(self, qstr):
    method query_async (line 64) | def query_async(self, qstr, callback=None):
  function cursorToColumns (line 69) | def cursorToColumns(cur, sheet):
  class MyTablesSheet (line 77) | class MyTablesSheet(Sheet):
    method iterload (line 80) | def iterload(self):
    method openRow (line 115) | def openRow(self, row):
  class MyTable (line 120) | class MyTable(Sheet):
    method iterload (line 121) | def iterload(self):

FILE: visidata/loaders/npy.py
  function open_npy (line 7) | def open_npy(vd, p):
  function open_npz (line 11) | def open_npz(vd, p):
  class NpySheet (line 17) | class NpySheet(Sheet):
    method iterload (line 18) | def iterload(self):
    method reloadCols (line 37) | def reloadCols(self):
  function _guess_type (line 62) | def _guess_type(shape, fmt):
  class NpzSheet (line 73) | class NpzSheet(vd.ZipSheet):
    method iterload (line 80) | def iterload(self):
    method openRow (line 85) | def openRow(self, row):
  function save_npy (line 95) | def save_npy(vd, p, sheet):

FILE: visidata/loaders/odf.py
  function open_ods (line 5) | def open_ods(vd, p):
  class OdsIndexSheet (line 9) | class OdsIndexSheet(IndexSheet):
    method iterload (line 10) | def iterload(self):
  function _get_cell_string_value (line 19) | def _get_cell_string_value(cell, text_s):
  class OdsSheet (line 37) | class OdsSheet(SequenceSheet):
    method iterload (line 38) | def iterload(self):

FILE: visidata/loaders/orgmode.py
  function open_org (line 34) | def open_org(vd, p):
  function open_forg (line 39) | def open_forg(vd, p):
  function open_orgdir (line 44) | def open_orgdir(vd, p):
  function encode_date (line 48) | def encode_date(dt=None):
  class OrgContentsColumn (line 58) | class OrgContentsColumn(WritableColumn):
    method setValue (line 59) | def setValue(self, row, v, setModified=True):
    method putValue (line 63) | def putValue(self, row, v):
  function sectionize (line 67) | def sectionize(lines):
  function orgmode_parse (line 90) | def orgmode_parse(all_lines):
  function _replace (line 126) | def _replace(node, newnode):
  function orgmode_parse_into (line 132) | def orgmode_parse_into(toprow, text):
  function orgmode_to_string (line 142) | def orgmode_to_string(section, prestars=''):
  function orgmode_parse_title (line 154) | def orgmode_parse_title(line):
  class OrgSheet (line 167) | class OrgSheet(Sheet):
    method __init__ (line 192) | def __init__(self, *args, **kwargs):
    method isSelectedParents (line 198) | def isSelectedParents(self, row):
    method isSelected (line 201) | def isSelected(self, row):
    method refreshRows (line 204) | def refreshRows(self):
    method _deepiter (line 207) | def _deepiter(self, objlist, depth=1):
    method openRows (line 217) | def openRows(self, rows):
    method closeRows (line 222) | def closeRows(self, rows=None):
    method newRow (line 230) | def newRow(self):
    method iterload (line 233) | def iterload(self):
    method parse_orgmd (line 263) | def parse_orgmd(self, path):
    method draw (line 274) | def draw(self, scr):
    method putChanges (line 278) | def putChanges(self):
    method save_all (line 299) | def save_all(self):
    method save (line 304) | def save(self, row):
  function paste_into (line 315) | def paste_into(sheet, row, sourcerows, cols):
  function paste_data_into (line 324) | def paste_data_into(sheet, row, sourcerows, cols):
  function combine_rows (line 332) | def combine_rows(sheet, rows):
  function _root (line 348) | def _root(row):
  function sysopen_row (line 355) | def sysopen_row(sheet, row):
  function save_org (line 363) | def save_org(vd, p, *vsheets):
  function sysopen_rows (line 374) | def sysopen_rows(sheet, rows):

FILE: visidata/loaders/pandas_freqtbl.py
  class DataFrameRowSliceAdapter (line 6) | class DataFrameRowSliceAdapter:
    method __init__ (line 13) | def __init__(self, df, mask):
    method __len__ (line 28) | def __len__(self):
    method __getitem__ (line 31) | def __getitem__(self, k):
    method __iter__ (line 39) | def __iter__(self):
    method __getattr__ (line 45) | def __getattr__(self, k):
  class DataFrameRowSliceIter (line 49) | class DataFrameRowSliceIter:
    method __init__ (line 50) | def __init__(self, df, mask_iloc, index=0):
    method __next__ (line 55) | def __next__(self):
  function makePandasFreqTable (line 65) | def makePandasFreqTable(sheet, *groupByCols):
  class PandasFreqTableSheet (line 70) | class PandasFreqTableSheet(PivotSheet):
    method selectRow (line 74) | def selectRow(self, row):
    method unselectRow (line 82) | def unselectRow(self, row):
    method addUndoSelection (line 86) | def addUndoSelection(self):
    method updateLargest (line 90) | def updateLargest(self, grouprow):
    method loader (line 93) | def loader(self):
    method openRow (line 166) | def openRow(self, row):
  function expand_source_rows (line 170) | def expand_source_rows(sheet, row):

FILE: visidata/loaders/parquet.py
  function open_parquet (line 6) | def open_parquet(vd, p):
  class ParquetColumn (line 10) | class ParquetColumn(Column):
    method readonly (line 12) | def readonly(self):
    method calcValue (line 15) | def calcValue(self, row):
    method putValue (line 27) | def putValue(self, row, val):
  class ParquetSheet (line 31) | class ParquetSheet(Sheet):
    method iterload (line 33) | def iterload(self):
  function save_parquet (line 57) | def save_parquet(vd, p, sheet):

FILE: visidata/loaders/pcap.py
  function open_pcap (line 19) | def open_pcap(vd, p):
  function manuf (line 26) | def manuf(mac):
  function macaddr (line 29) | def macaddr(addrbytes):
  function macmanuf (line 33) | def macmanuf(mac):
  function norm_host (line 49) | def norm_host(host):
  function FlagGetter (line 75) | def FlagGetter(flagfield):
  function init_pcap (line 81) | def init_pcap():
  function read_pcap (line 99) | def read_pcap(f):
  function load_oui (line 108) | def load_oui(url):
  function load_iana (line 122) | def load_iana(url):
  class Host (line 132) | class Host:
    method get_host (line 137) | def get_host(cls, pkt, field='src'):
    method get_by_ip (line 156) | def get_by_ip(cls, ip):
    method __init__ (line 163) | def __init__(self, mac, ip):
    method __str__ (line 168) | def __str__(self):
    method __lt__ (line 171) | def __lt__(self, x):
    method hostname (line 177) | def hostname(self):
  function load_consts (line 180) | def load_consts(outdict, module, attrprefix):
  function getTuple (line 186) | def getTuple(pkt):
  function getService (line 199) | def getService(tup):
  function get_transport (line 208) | def get_transport(pkt):
  function get_port (line 234) | def get_port(pkt, field='sport'):
  class EtherSheet (line 238) | class EtherSheet(Sheet):
  class IPSheet (line 251) | class IPSheet(Sheet):
    method iterload (line 269) | def iterload(self):
  class TCPSheet (line 276) | class TCPSheet(IPSheet):
    method iterload (line 284) | def iterload(self):
  class UDPSheet (line 289) | class UDPSheet(IPSheet):
    method iterload (line 297) | def iterload(self):
  class PcapSheet (line 303) | class PcapSheet(Sheet):
    method iterload (line 325) | def iterload(self):
  class PcapFlowsSheet (line 353) | class PcapFlowsSheet(Sheet):
    method iterload (line 368) | def iterload(self):
    method openRow (line 393) | def openRow(self, row):
  function flowname (line 397) | def flowname(flow):
  function try_apply (line 400) | def try_apply(func, *args, **kwargs):

FILE: visidata/loaders/pdf.py
  function open_pdf (line 9) | def open_pdf(vd, p):
  class PdfMinerSheet (line 15) | class PdfMinerSheet(TableSheet):
    method iterload (line 22) | def iterload(self):
  class TabulaSheet (line 40) | class TabulaSheet(IndexSheet):
    method iterload (line 41) | def iterload(self):

FILE: visidata/loaders/png.py
  function open_png (line 7) | def open_png(vd, p):
  class PNGSheet (line 11) | class PNGSheet(Sheet):
    method newRow (line 17) | def newRow(self):
    method iterload (line 20) | def iterload(self):
  class PNGDrawing (line 31) | class PNGDrawing(Canvas):
    method __init__ (line 35) | def __init__(self, *args, **kwargs):
    method togglePixel (line 38) | def togglePixel(self, rows):
    method setPixel (line 45) | def setPixel(self, rows, attr):
    method reload (line 53) | def reload(self):
  function save_png (line 62) | def save_png(vd, p, vs):
  function blockchar (line 81) | def blockchar(i:int):

FILE: visidata/loaders/postgres.py
  function codeToType (line 10) | def codeToType(type_code, colname):
  function openurl_rds (line 24) | def openurl_rds(vd, url, filetype=None):
  function openurl_postgres (line 45) | def openurl_postgres(vd, url, filetype=None):
  class SQL (line 63) | class SQL:
    method __init__ (line 64) | def __init__(self, conn):
    method cur (line 67) | def cur(self, qstr):
    method query_async (line 75) | def query_async(self, qstr, callback=None):
  function postgresGetColumns (line 82) | def postgresGetColumns(vd, cur):
  class PgTablesSheet (line 88) | class PgTablesSheet(Sheet):
    method loader (line 91) | def loader(self):
    method openRow (line 117) | def openRow(self, row):
  class PgTable (line 122) | class PgTable(Sheet):
    method reload (line 124) | def reload(self):

FILE: visidata/loaders/psv.py
  function open_psv (line 5) | def open_psv(vd, p):
  class PsvSheet (line 10) | class PsvSheet(TsvSheet):
  function save_psv (line 15) | def save_psv(vd, p, vs):

FILE: visidata/loaders/rec.py
  function open_rec (line 7) | def open_rec(vd, p):
  function decode_multiline (line 10) | def decode_multiline(line, fp):
  function encode_multiline (line 27) | def encode_multiline(s):
  function get_kv (line 31) | def get_kv(line):
  class RecSheet (line 34) | class RecSheet(TableSheet):
    method addColumn (line 35) | def addColumn(self, *cols, index=None):
  class RecIndexSheet (line 42) | class RecIndexSheet(IndexSheet):
    method iterload (line 43) | def iterload(self):
  function save_rec (line 125) | def save_rec(vd, p, *vsheets):

FILE: visidata/loaders/s3.py
  class S3Path (line 37) | class S3Path(Path):
    method __init__ (line 42) | def __init__(self, path, version_aware=None, version_id=None):
    method fs (line 49) | def fs(self):
    method fs (line 61) | def fs(self, val):
    method open (line 64) | def open(self, mode='r', **kwargs):
  class S3DirSheet (line 94) | class S3DirSheet(Sheet):
    method __init__ (line 109) | def __init__(self, name, source, version_aware=None):
    method object_display_name (line 123) | def object_display_name(self, row):
    method iterload (line 136) | def iterload(self):
    method download (line 163) | def download(self, rows, savepath):
    method open_rows (line 171) | def open_rows(self, rows):
    method join_rows (line 184) | def join_rows(self, rows):
    method refresh_path (line 197) | def refresh_path(self, path=None):
    method toggle_versioning (line 205) | def toggle_versioning(self):
  function openurl_s3 (line 217) | def openurl_s3(vd, p, filetype):

FILE: visidata/loaders/sas.py
  function open_xpt (line 11) | def open_xpt(vd, p):
  function open_sas7bdat (line 15) | def open_sas7bdat(vd, p):
  class XptSheet (line 18) | class XptSheet(Sheet):
    method iterload (line 19) | def iterload(self):
  class SasSheet (line 38) | class SasSheet(Sheet):
    method iterload (line 39) | def iterload(self):

FILE: visidata/loaders/scrape.py
  function soup (line 15) | def soup(vd, s):
  function open_scrape (line 22) | def open_scrape(vd, p):
  function node_name (line 33) | def node_name(node):
  function calc_selector (line 44) | def calc_selector(node):
  class HtmlAttrColumn (line 62) | class HtmlAttrColumn(Column):
    method calcValue (line 63) | def calcValue(self, row):
  function prev_header (line 67) | def prev_header(r):
  class HtmlElementsSheet (line 77) | class HtmlElementsSheet(TableSheet):
    method iterload (line 98) | def iterload(self):
    method html_parents (line 104) | def html_parents(self, row):
    method rootSource (line 110) | def rootSource(self):
    method openRows (line 113) | def openRows(self, rows):
    method openRow (line 117) | def openRow(self, row):
  class DocsSelectorColumn (line 122) | class DocsSelectorColumn(Column):
    method calcValue (line 123) | def calcValue(self, row):
  class SelectorColumn (line 126) | class SelectorColumn(Column):
    method calcValue (line 127) | def calcValue(self, row):
  class HtmlDocsSheet (line 132) | class HtmlDocsSheet(TableSheet):
    method iterload (line 149) | def iterload(self):
    method addRow (line 157) | def addRow(self, row, index=None):
    method openRow (line 161) | def openRow(self, row):
  function soupstr (line 164) | def soupstr(coll):
  function scrape_urls (line 170) | def scrape_urls(sheet, col, rows):

FILE: visidata/loaders/shp.py
  function open_shp (line 10) | def open_shp(vd, p):
  function shptype (line 24) | def shptype(ftype, declen):
  class ShapeSheet (line 31) | class ShapeSheet(Sheet):
    method iterload (line 36) | def iterload(self):
    method reloadCols (line 43) | def reloadCols(self):
  class ShapeMap (line 52) | class ShapeMap(InvertedCanvas):
    method reload (line 57) | def reload(self):
  function save_geojson (line 82) | def save_geojson(vd, p, vs):

FILE: visidata/loaders/spss.py
  function open_spss (line 5) | def open_spss(vd, p):
  class SpssSheet (line 10) | class SpssSheet(Sheet):
    method loader (line 11) | def loader(self):

FILE: visidata/loaders/sqlite.py
  function requery (line 10) | def requery(url, **kwargs):
  function guess_sqlite (line 21) | def guess_sqlite(vd, p):
  function open_sqlite (line 27) | def open_sqlite(vd, p):
  function openurl_sqlite (line 33) | def openurl_sqlite(vd, p, filetype=None):
  class SqliteSheet (line 40) | class SqliteSheet(Sheet):
    method conn (line 47) | def conn(self):
    method rawSql (line 60) | def rawSql(self, q:str) -> 'SqliteSheet':
    method sidebar (line 64) | def sidebar(self):
    method execute (line 70) | def execute(self, conn, sql, parms=None):
    method iterload_table (line 75) | def iterload_table(self, tblname:str):
    method iterload_query (line 114) | def iterload_query(self, query:str):
    method iterload (line 132) | def iterload(self):
    method putChanges (line 141) | def putChanges(self):
  class SqliteIndexSheet (line 205) | class SqliteIndexSheet(SqliteSheet, IndexSheet):
    method iterload (line 210) | def iterload(self):
    method putChanges (line 217) | def putChanges(self):
  function save_sqlite (line 243) | def save_sqlite(vd, p, *vsheets):

FILE: visidata/loaders/texttables.py
  function save_table (line 7) | def save_table(path, *sheets, fmt=fmt):

FILE: visidata/loaders/toml.py
  function open_toml (line 12) | def open_toml(vd, p):
  class TomlSheet (line 16) | class TomlSheet(PythonSheet):
    method loader (line 35) | def loader(self):

FILE: visidata/loaders/tsv.py
  function open_tsv (line 16) | def open_tsv(vd, p):
  function adaptive_bufferer (line 20) | def adaptive_bufferer(fp, max_buffer_size=65536):
  function splitter (line 52) | def splitter(stream, delim='\n'):
  class TsvSheet (line 69) | class TsvSheet(SequenceSheet):
    method iterload (line 70) | def iterload(self):
  function save_tsv (line 100) | def save_tsv(vd, p, vs):

FILE: visidata/loaders/ttf.py
  function open_ttf (line 5) | def open_ttf(vd, p):
  class TTFTablesSheet (line 10) | class TTFTablesSheet(Sheet):
    method openRow (line 23) | def openRow(self, row):
    method iterload (line 26) | def iterload(self):
  class TTFGlyphsSheet (line 34) | class TTFGlyphsSheet(Sheet):
    method openRow (line 45) | def openRow(self, row):
    method iterload (line 48) | def iterload(self):
  function makePen (line 55) | def makePen(*args, **kwargs):

FILE: visidata/loaders/unzip_http.py
  function error (line 62) | def error(s):
  function warning (line 65) | def warning(s):
  function get_bits (line 68) | def get_bits(val:int, *args):
  class RemoteZipInfo (line 76) | class RemoteZipInfo:
    method __init__ (line 77) | def __init__(self, filename:str='',
    method is_dir (line 92) | def is_dir(self):
    method parse_extra (line 95) | def parse_extra(self, extra):
  class RemoteZipFile (line 120) | class RemoteZipFile:
    method __init__ (line 128) | def __init__(self, url):
    method __enter__ (line 134) | def __enter__(self):
    method __exit__ (line 137) | def __exit__(self, a, b, c):
    method files (line 141) | def files(self):
    method infolist (line 146) | def infolist(self):
    method namelist (line 149) | def namelist(self):
    method infoiter (line 152) | def infoiter(self):
    method extract (line 220) | def extract(self, member, path=None, pwd=None):
    method extractall (line 236) | def extractall(self, path=None, members=None, pwd=None):
    method get_range (line 240) | def get_range(self, start, n):
    method matching_files (line 243) | def matching_files(self, *globs):
    method open (line 248) | def open(self, fn):
    method open_text (line 269) | def open_text(self, fn):
  class RemoteZipStream (line 273) | class RemoteZipStream(io.RawIOBase):
    method __init__ (line 274) | def __init__(self, fp, info):
    method readable (line 280) | def readable(self):
    method readinto (line 283) | def readinto(self, b):
    method read (line 288) | def read(self, n):
  class StreamProgress (line 304) | class StreamProgress:
    method __init__ (line 305) | def __init__(self, fp, name='', total=0):
    method read (line 313) | def read(self, n):
  function list_files (line 329) | def list_files(rzf):
  function extract_one (line 340) | def extract_one(outfile, rzf, f, ofname):
  function download_file (line 348) | def download_file(f, rzf, args):
  function main (line 365) | def main():

FILE: visidata/loaders/usv.py
  function open_usv (line 5) | def open_usv(vd, p):
  class UsvSheet (line 11) | class UsvSheet(TsvSheet):
  function save_usv (line 16) | def save_usv(vd, p, vs):

FILE: visidata/loaders/vcf.py
  function open_vcf (line 7) | def open_vcf(vd, p):
  function unbox (line 10) | def unbox(col, row):
  class VcfSheet (line 19) | class VcfSheet(PythonSheet):
    method reload (line 22) | def reload(self):

FILE: visidata/loaders/vds.py
  function open_vds (line 11) | def open_vds(vd, p):
  function save_vds (line 16) | def save_vds(vd, p, *sheets):
  class VdsIndexSheet (line 47) | class VdsIndexSheet(IndexSheet):
    method iterload (line 48) | def iterload(self):
  class VdsSheet (line 61) | class VdsSheet(JsonSheet):
    method newRow (line 62) | def newRow(self):
    method iterload (line 65) | def iterload(self):

FILE: visidata/loaders/vdx.py
  function open_vdx (line 11) | def open_vdx(vd, p):
  class CommandLogSimple (line 17) | class CommandLogSimple(CommandLogBase, Sheet):
    method iterload (line 19) | def iterload(self):
  function save_vdx (line 61) | def save_vdx(vd, p, *vsheets):
  function runvdx (line 83) | def runvdx(vd, vdx:str):

FILE: visidata/loaders/xlsb.py
  function guess_xls (line 6) | def guess_xls(vd, p):
  function open_xlsb (line 12) | def open_xlsb(vd, p):
  class XlsbIndex (line 16) | class XlsbIndex(IndexSheet):
    method iterload (line 17) | def iterload(self):

FILE: visidata/loaders/xlsx.py
  function open_xls (line 16) | def open_xls(vd, p):
  function open_xlsx (line 21) | def open_xlsx(vd, p):
  class XlsxIndexSheet (line 25) | class XlsxIndexSheet(IndexSheet):
    method iterload (line 37) | def iterload(self):
  class XlsxSheet (line 45) | class XlsxSheet(SequenceSheet):
    method setCols (line 50) | def setCols(self, headerrows):
    method addRow (line 71) | def addRow(self, row, index=None):
    method iterload (line 77) | def iterload(self):
    method addXlsxMetaColumns (line 84) | def addXlsxMetaColumns(self, column_letter, column_name):
    method paste_after (line 98) | def paste_after(self, rowidx):
  class XlsIndexSheet (line 103) | class XlsIndexSheet(IndexSheet):
    method iterload (line 113) | def iterload(self):
  class XlsSheet (line 120) | class XlsSheet(SequenceSheet):
    method iterload (line 121) | def iterload(self):
  function xls_name (line 128) | def xls_name(vs):
  function save_xlsx (line 139) | def save_xlsx(vd, p, *sheets):
  function save_xls (line 182) | def save_xls(vd, p, *sheets):
  function colorize_xlsx_cell (line 208) | def colorize_xlsx_cell(sheet, col, row):
  function xlsx_color_to_xterm256 (line 222) | def xlsx_color_to_xterm256(sheet, color) -> str:
  function theme_and_tint_to_rgb (line 240) | def theme_and_tint_to_rgb(sheet, theme, tint) -> str:
  function theme_colors (line 249) | def theme_colors(sheet):
  function rgb_to_ms_hls (line 271) | def rgb_to_ms_hls(red, green=None, blue=None):
  function ms_hls_to_rgb (line 285) | def ms_hls_to_rgb(hue, lightness=None, saturation=None):
  function rgb_to_hex (line 291) | def rgb_to_hex(red, green=None, blue=None):
  function tint_luminance (line 297) | def tint_luminance(tint, lum):

FILE: visidata/loaders/xml.py
  function open_xml (line 8) | def open_xml(vd, p):
  function unns (line 13) | def unns(k):
  function AttribColumn (line 20) | def AttribColumn(name, k, **kwargs):
  class XmlSheet (line 26) | class XmlSheet(Sheet):
    method showColumnsBasedOnRow (line 43) | def showColumnsBasedOnRow(self, row):
    method iterload (line 49) | def iterload(self):
    method openRow (line 72) | def openRow(self, row):
    method addRow (line 75) | def addRow(self, elem):
  function save_xml (line 86) | def save_xml(vd, p, vs):

FILE: visidata/loaders/xword.py
  function open_puz (line 10) | def open_puz(vd, p):
  function open_xd (line 14) | def open_xd(vd, p):
  class CrosswordsSheet (line 21) | class CrosswordsSheet(Sheet):
    method reload (line 33) | def reload(self):
    method openRow (line 38) | def openRow(self):
  class GridSheet (line 42) | class GridSheet(Sheet):
    method reload (line 49) | def reload(self):
  class CrosswordSheet (line 75) | class CrosswordSheet(Sheet):
    method reload (line 85) | def reload(self):
    method openRow (line 90) | def openRow(self):
  class PuzSheet (line 94) | class PuzSheet(CrosswordSheet):
    method reload (line 96) | def reload(self):
  function save_xd (line 103) | def save_xd(vd, p, vs):

FILE: visidata/loaders/yaml.py
  function open_yml (line 7) | def open_yml(vd, p):
  class YamlSheet (line 12) | class YamlSheet(JsonSheet):
    method iterload (line 13) | def iterload(self):

FILE: visidata/macros.py
  class MacroSheet (line 15) | class MacroSheet(IndexSheet):
    method iterload (line 33) | def iterload(self):
    method commitDeleteRow (line 36) | def commitDeleteRow(self, row):
    method putChanges (line 52) | def putChanges(self):
    method newRow (line 60) | def newRow(self):
  function macrosheet (line 65) | def macrosheet(vd):
  function loadMacro (line 70) | def loadMacro(vd, p:Path):
  function runMacro (line 85) | def runMacro(vd, binding:str):
  function setMacro (line 93) | def setMacro(vd, ks:str, vs, helpstr=''):
  function saveMacro (line 105) | def saveMacro(self, rows, ks):
  function afterExecSheet (line 119) | def afterExecSheet(cmdlog, sheet, escaped, err):
  function startMacro (line 131) | def startMacro(cmdlog):
  function run (line 158) | def run(vd, *args, **kwargs):
  function reloadMacros (line 163) | def reloadMacros(vd):

FILE: visidata/main.py
  function eval_vd (line 37) | def eval_vd(logpath, *args, **kwargs):
  function duptty (line 61) | def duptty():
  function parsePos (line 97) | def parsePos(vd, arg:str, inputs:'list[tuple[str, dict]]'=None):
  function outputProgressEvery (line 139) | def outputProgressEvery(vd, sheet, seconds:float=0.5):
  function moveToPos (line 155) | def moveToPos(vd, sources, sheet_desc, startcol, startrow):
  function sheet_from_description (line 177) | def sheet_from_description(vd, sources, sheet_desc):
  function queue_move_to_pos (line 233) | def queue_move_to_pos(vd, sources, moves):
  function attempt_move_to_pos (line 248) | def attempt_move_to_pos(vd, sources, sheet_desc, startcol, startrow):
  function afterLoad (line 275) | def afterLoad(sheet):
  function main_vd (line 283) | def main_vd():
  function vd_cli (line 533) | def vd_cli():

FILE: visidata/mainloop.py
  class ReturnValue (line 20) | class ReturnValue(BaseException):
  function callNoExceptions (line 26) | def callNoExceptions(vd, func, *args, **kwargs):
  function callIgnoreExceptions (line 35) | def callIgnoreExceptions(vd, func, *args, **kwargs):
  function drawSheet (line 46) | def drawSheet(vd, scr, sheet):
  function setWindows (line 75) | def setWindows(vd, scr, pct=None):
  function draw_all (line 125) | def draw_all(vd):
  function runresult (line 164) | def runresult(vd):
  function mainloop (line 174) | def mainloop(vd, scr):
  function _playNextQueuedCommand (line 264) | def _playNextQueuedCommand(vd):
  function get_curses_timeout (line 282) | def get_curses_timeout(vd) -> int:
  function initCurses (line 310) | def initCurses(vd):
  function wrapper (line 339) | def wrapper(f, *args, **kwargs):
  function run (line 348) | def run(vd, *sheetlist):
  function addCommand (line 375) | def addCommand(vd, *args, **kwargs):

FILE: visidata/memory.py
  function memoValue (line 8) | def memoValue(vd, name, value, dispvalue):
  class MemorySheet (line 13) | class MemorySheet(Sheet):
    method rows (line 21) | def rows(self):
    method rows (line 25) | def rows(self, v):
  function memosSheet (line 30) | def memosSheet(vd):
  function inputMemoName (line 35) | def inputMemoName(vd, value):

FILE: visidata/menu.py
  function hintStatus (line 27) | def hintStatus(vd):
  function menudraw (line 36) | def menudraw(*args):
  function Menu (line 40) | def Menu(title, *args):
  function walkmenu (line 48) | def walkmenu(item, menupath=[]):
  function _finditem (line 56) | def _finditem(menus, item:Union[str,int]):
  function getMenuItem (line 67) | def getMenuItem(sheet, menupath:List[str]=None):
  function addMenuItem (line 83) | def addMenuItem(vd, *args):
  function addMenuItems (line 92) | def addMenuItems(vd, *itemgroups):
  function addMenu (line 107) | def addMenu(vd, *args):
  function _intMenuPath (line 128) | def _intMenuPath(obj, menupath):
  function menuitemAvailable (line 159) | def menuitemAvailable(sheet, item):
  function drawSubmenu (line 164) | def drawSubmenu(vd, scr, sheet, y, x, menus, level, disp_menu_boxchars=''):
  function nop (line 249) | def nop(vd, *args, **kwargs):
  function _done (line 253) | def _done(vd, *args, **kwargs):
  function menus (line 260) | def menus(sheet):
  function drawMenu (line 295) | def drawMenu(vd, scr, sheet):
  function pressMenu (line 386) | def pressMenu(sheet, *args):
  function checkMenu (line 407) | def checkMenu(sheet):
  function runMenu (line 412) | def runMenu(vd):

FILE: visidata/metasheets.py
  class ColumnsSheet (line 14) | class ColumnsSheet(Sheet):
    class ValueColumn (line 37) | class ValueColumn(WritableColumn):
      method calcValue (line 39) | def calcValue(self, srcCol):
      method setValue (line 41) | def setValue(self, srcCol, val, setModified=True):
    method nSourceCols (line 70) | def nSourceCols(self):
    method loader (line 73) | def loader(self):
    method newRow (line 81) | def newRow(self):
  class MetaSheet (line 86) | class MetaSheet(Sheet):
  class VisiDataMetaSheet (line 89) | class VisiDataMetaSheet(TsvSheet):
  function allColumnsSheet (line 101) | def allColumnsSheet(vd):
  function save_visidatarc (line 106) | def save_visidatarc(vd, p, vs):
  function join_cols (line 118) | def join_cols(sheet):

FILE: visidata/modify.py
  function couldOverwrite (line 18) | def couldOverwrite(vd) -> bool:
  function confirmOverwrite (line 24) | def confirmOverwrite(vd, path, msg:str=''):
  function _deferredAdds (line 39) | def _deferredAdds(sheet):
  function _deferredMods (line 43) | def _deferredMods(sheet):
  function _deferredDels (line 47) | def _deferredDels(sheet):
  function preloadHook (line 58) | def preloadHook(sheet):
  function afterLoad (line 65) | def afterLoad(sheet):
  function rowAdded (line 69) | def rowAdded(self, row):
  function cellChanged (line 80) | def cellChanged(col, row, val):
  function rowDeleted (line 116) | def rowDeleted(self, row):
  function addRows (line 131) | def addRows(sheet, rows, index=None, undo=True):
  function deleteBy (line 152) | def deleteBy(sheet, func, commit=False, undo=True):
  function isDeleted (line 200) | def isDeleted(self, row):
  function isChanged (line 205) | def isChanged(self, col, row):
  function getSourceValue (line 218) | def getSourceValue(col, row):
  function commitAdds (line 224) | def commitAdds(self):
  function commitMods (line 244) | def commitMods(sheet):
  function commitDeletes (line 261) | def commitDeletes(self):
  function commitAddRow (line 271) | def commitAddRow(self, row):
  function commitDeleteRow (line 276) | def commitDeleteRow(self, row):
  function putChanges (line 282) | def putChanges(sheet):
  function getDeferredChanges (line 292) | def getDeferredChanges(sheet):
  function changestr (line 312) | def changestr(self, adds, mods, deletes):
  function commit (line 329) | def commit(sheet, *rows):
  function new_rows (line 344) | def new_rows(sheet, n):

FILE: visidata/motd.py
  function domotd (line 22) | def domotd(vd):

FILE: visidata/mouse.py
  function initCurses (line 15) | def initCurses(vd):
  function enableMouse (line 31) | def enableMouse(vd, b:bool) -> bool:  #2913 #2851
  function clearCaches (line 40) | def clearCaches(vd):
  function onMouse (line 45) | def onMouse(vd, scr, x, y, w, h, **kwargs):
  function getMouse (line 52) | def getMouse(vd, _x, _y, button):
  function parseMouse (line 59) | def parseMouse(vd, **kwargs):
  function handleMouse (line 90) | def handleMouse(vd, sheet):
  function visibleColAtX (line 127) | def visibleColAtX(sheet, x):
  function visibleRowAtY (line 134) | def visibleRowAtY(sheet, y):
  function go_mouse (line 141) | def go_mouse(sheet):

FILE: visidata/movement.py
  function rotateRange (line 6) | def rotateRange(n, idx, reverse=False):
  function pageLeft (line 26) | def pageLeft(self):
  function moveToNextRow (line 64) | def moveToNextRow(vs, func, reverse=False, msg='no different value up th...
  function visibleWidth (line 84) | def visibleWidth(self):

FILE: visidata/optionssheet.py
  function optionsSheet (line 8) | def optionsSheet(sheet):
  function globalOptionsSheet (line 12) | def globalOptionsSheet(vd):
  class OptionsSheet (line 17) | class OptionsSheet(Sheet):
    method guide (line 38) | def guide(self):
    method diffOption (line 49) | def diffOption(self, optname):
    method editOption (line 52) | def editOption(self, row):
    method valueColName (line 70) | def valueColName(self):
    method beforeLoad (line 73) | def beforeLoad(self):
    method iterload (line 77) | def iterload(self):
    method newRow (line 87) | def newRow(self):
  function commit (line 96) | def commit(sheet, *rows):

FILE: visidata/path.py
  function pkg_resources_files (line 40) | def pkg_resources_files(vd, package):
  function vstat (line 52) | def vstat(path, force=False):
  function filesize (line 58) | def filesize(path):
  function modtime (line 68) | def modtime(path):
  class BytesIOWrapper (line 74) | class BytesIOWrapper(io.BufferedReader):
    method __init__ (line 77) | def __init__(self, text_io_buffer, encoding=None, errors=None, **kwargs):
    method _encoding_call (line 82) | def _encoding_call(self, method_name, *args, **kwargs):
    method read (line 87) | def read(self, size=-1):
    method read1 (line 90) | def read1(self, size=-1):
    method peek (line 93) | def peek(self, size=-1):
  class FileProgress (line 97) | class FileProgress:
    method __init__ (line 99) | def __init__(self, path, fp, mode='r', **kwargs):
    method close (line 123) | def close(self, *args, **kwargs):
    method read (line 129) | def read(self, size=-1):
    method readline (line 136) | def readline(self, size=-1):
    method __getattr__ (line 142) | def __getattr__(self, k):
    method __enter__ (line 145) | def __enter__(self):
    method __next__ (line 149) | def __next__(self):
    method __iter__ (line 154) | def __iter__(self):
    method __exit__ (line 162) | def __exit__(self, type, value, tb):
  class Path (line 166) | class Path(os.PathLike):
    method __init__ (line 168) | def __init__(self, given, fp=None, fptext=None, lines=None, filesize=N...
    method name (line 178) | def name(self):
    method given (line 185) | def given(self):
    method given (line 190) | def given(self, given):
    method options (line 215) | def options(self):
    method __getattr__ (line 218) | def __getattr__(self, k):
    method __fspath__ (line 230) | def __fspath__(self):
    method __lt__ (line 233) | def __lt__(self, a):
    method __truediv__ (line 238) | def __truediv__(self, a):
    method has_fp (line 241) | def has_fp(self):
    method open (line 245) | def open(self, mode='rt', encoding=None, encoding_errors=None, newline...
    method open_bytes (line 251) | def open_bytes(self, mode='rb'):
    method open_text (line 271) | def open_text(self, mode='rt', encoding=None, encoding_errors=None, ne...
    method read_text (line 303) | def read_text(self, *args, **kwargs):
    method _open (line 320) | def _open(self, *args, **kwargs):
    method __iter__ (line 351) | def __iter__(self):
    method read_bytes (line 356) | def read_bytes(self):
    method is_fifo (line 362) | def is_fifo(self):
    method is_local (line 366) | def is_local(self):
    method is_url (line 370) | def is_url(self):
    method __str__ (line 374) | def __str__(self):
    method stat (line 381) | def stat(self, force=False):
    method exists (line 390) | def exists(self):
    method scheme (line 397) | def scheme(self):
    method iterdir (line 402) | def iterdir(self):  #2188
    method with_name (line 406) | def with_name(self, name):
  class RepeatFile (line 416) | class RepeatFile:
    method __init__ (line 419) | def __init__(self, iter_lines, lines=None):
    method __enter__ (line 426) | def __enter__(self):
    method __exit__ (line 430) | def __exit__(self, a,b,c):
    method reopen (line 433) | def reopen(self):
    method read (line 437) | def read(self, n=None):
    method write (line 457) | def write(self, s):
    method tell (line 460) | def tell(self):
    method seek (line 464) | def seek(self, offset, whence=io.SEEK_SET):
    method readline (line 475) | def readline(self, size=-1):
    method __iter__ (line 483) | def __iter__(self):
    method __next__ (line 486) | def __next__(self):
    method readable (line 489) | def readable(self):
    method writable (line 492) | def writable(self):
    method seekable (line 495) | def seekable(self):
    method read1 (line 498) | def read1(self, n=-1):
    method peek (line 501) | def peek(self, n=-1):
    method exists (line 507) | def exists(self):
  class RepeatFileIter (line 511) | class RepeatFileIter:
    method __init__ (line 512) | def __init__(self, rf):
    method __iter__ (line 516) | def __iter__(self):
    method __next__ (line 519) | def __next__(self):

FILE: visidata/pivot.py
  function makePivot (line 14) | def makePivot(source, groupByCols, pivotCols):
  function makeErrorKey (line 20) | def makeErrorKey(col):
  function formatRange (line 26) | def formatRange(col, numeric_key):
  class RangeColumn (line 38) | class RangeColumn(Column):
    method __init__ (line 39) | def __init__(self, *args, **kwargs):
    method formatter_range (line 43) | def formatter_range(self, fmtstr):
    method _format (line 46) | def _format(self, typedval, *args, **kwargs):
  class AggrColumn (line 52) | class AggrColumn(Column):
    method calcValue (line 53) | def calcValue(col, row):
  function makeAggrColumn (line 59) | def makeAggrColumn(aggcol, aggregator):
  class PivotSheet (line 71) | class PivotSheet(Sheet):
    method __init__ (line 75) | def __init__(self, *names, groupByCols=[], pivotCols=[], **kwargs):
    method isNumericRange (line 81) | def isNumericRange(self, col):
    method resetCols (line 84) | def resetCols(self):
    method openRow (line 105) | def openRow(self, row):
    method openCell (line 112) | def openCell(self, col, row):
    method loader (line 119) | def loader(self):
    method addAggregateCols (line 125) | def addAggregateCols(self):
    method groupRows (line 190) | def groupRows(self, rowfunc=None):
    method afterLoad (line 284) | def afterLoad(self):
  function addcol_aggr (line 294) | def addcol_aggr(sheet, col):

FILE: visidata/plugins.py
  function pluginConfig (line 17) | def pluginConfig(self):
  function pluginConfigLines (line 22) | def pluginConfigLines(self):
  function _plugin_import_name (line 25) | def _plugin_import_name(self, plugin):
  function enablePlugin (line 34) | def enablePlugin(vd, plugin:str):
  function removePlugin (line 41) | def removePlugin(vd, plugin:str):
  function pluginsSheet (line 68) | def pluginsSheet(p):
  class PluginsSheet (line 72) | class PluginsSheet(Sheet):
    method iterload (line 83) | def iterload(self):

FILE: visidata/pyobj.py
  class PythonSheet (line 16) | class PythonSheet(Sheet):
    method openRow (line 17) | def openRow(self, row):
  class PythonAtomSheet (line 20) | class PythonAtomSheet(PythonSheet):
    method loader (line 28) | def loader(self):
    method openRow (line 32) | def openRow(self, row):
    method openCell (line 34) | def openCell(self, col, row, rowidx=None):
    method openRowPyobj (line 36) | def openRowPyobj(self, rowidx):
    method openCellPyobj (line 38) | def openCellPyobj(self, col, rowidx):
    method newRow (line 40) | def newRow(self):
  function view (line 45) | def view(vd, obj):
  function PyobjColumns (line 49) | def PyobjColumns(obj):
  function AttrColumns (line 63) | def AttrColumns(attrnames):
  function SheetList (line 68) | def SheetList(*names, **kwargs):
  class ListOfPyobjSheet (line 85) | class ListOfPyobjSheet(PythonSheet):
    method loader (line 87) | def loader(self):
  class ListOfDictSheet (line 101) | class ListOfDictSheet(PythonSheet):
    method reload (line 103) | def reload(self):
  class ListOfNamedTupleSheet (line 114) | class ListOfNamedTupleSheet(PythonSheet):
    method reload (line 116) | def reload(self):
  class SheetNamedTuple (line 124) | class SheetNamedTuple(PythonSheet):
    method __init__ (line 129) | def __init__(self, *names, **kwargs):
    method reload (line 132) | def reload(self):
    method openRow (line 135) | def openRow(self, row):
  class SheetDict (line 140) | class SheetDict(PythonSheet):
    method reload (line 148) | def reload(self):
    method openRow (line 151) | def openRow(self, row):
  class ColumnSourceAttr (line 155) | class ColumnSourceAttr(WritableColumn):
    method calcValue (line 157) | def calcValue(self, attrname):
    method setValue (line 159) | def setValue(self, attrname, value, setModified=True):
  function docstring (line 165) | def docstring(obj, attr):
  class PyobjSheet (line 172) | class PyobjSheet(PythonSheet):
    method __new__ (line 183) | def __new__(cls, *names, **kwargs):
    method reload (line 209) | def reload(self):
    method openRow (line 226) | def openRow(self, row):
  function openRow (line 233) | def openRow(sheet, row, rowidx=None):
  function openCell (line 252) | def openCell(sheet, col, row, rowidx=None):
  function openRows (line 264) | def openRows(sheet, rows):
  function openCells (line 272) | def openCells(sheet, col, rows):
  function openRowPyobj (line 279) | def openRowPyobj(sheet, rowidx):
  function openCellPyobj (line 285) | def openCellPyobj(sheet, col, rowidx):
  function inputPythonExpr (line 293) | def inputPythonExpr(sheet):

FILE: visidata/rename_col.py
  function hint_rename_col (line 4) | def hint_rename_col(sheet):
  function addUndoColNames (line 10) | def addUndoColNames(vd, cols):
  function updateColNames (line 19) | def updateColNames(sheet, rows, cols, overwrite=False):

FILE: visidata/save.py
  function safe_trdict (line 12) | def safe_trdict(vs, delimiter=None):
  function iterdispvals (line 29) | def iterdispvals(sheet, *cols, format=False, delimiter=None):
  function itervals (line 78) | def itervals(sheet, *cols, format=False):
  function getDefaultSaveName (line 83) | def getDefaultSaveName(sheet):
  function saveCols (line 99) | def saveCols(vd, cols):
  function saveSheets (line 113) | def saveSheets(vd, givenpath, *vsheets, confirm_overwrite=True):
  function save_zip (line 178) | def save_zip(vd, p, *vsheets):
  function save_txt (line 194) | def save_txt(vd, p, *vsheets):
  function rootSheet (line 208) | def rootSheet(sheet):

FILE: visidata/search.py
  function moveRegex (line 17) | def moveRegex(vd, sheet, *args, **kwargs):
  function searchRegex (line 24) | def searchRegex(vd, sheet, moveCursor=False, reverse=False, regex_flags=...
  function searchInputRegex (line 80) | def searchInputRegex(sheet, action:str, columns:str='cursorCol'):
  function moveInputRegex (line 87) | def moveInputRegex(sheet, action:str, type="regex", **kwargs):
  function search_expr (line 95) | def search_expr(sheet, expr, reverse=False, curcol=None):
  function moveExpr (line 111) | def moveExpr(vd, sheet, reverse=False):
  function searchNext (line 128) | def searchNext(vd, sheet, reverse=False):
  function clear_search (line 139) | def clear_search(sheet):

FILE: visidata/selection.py
  function isSelected (line 17) | def isSelected(self, row):
  function toggle (line 23) | def toggle(self, rows, add_undo=True):
  function beforeLoad (line 35) | def beforeLoad(self):
  function select_row (line 40) | def select_row(self, row, add_undo=True):
  function toggle_row (line 48) | def toggle_row(self, row, add_undo=True):
  function unselect_row (line 59) | def unselect_row(self, row, add_undo=True):
  function selectRow (line 67) | def selectRow(self, row):
  function unselectRow (line 73) | def unselectRow(self, row):
  function clearSelected (line 82) | def clearSelected(self):
  function select (line 89) | def select(self, rows, status=True, progress=True, add_undo=True):
  function unselect (line 107) | def unselect(self, rows, status=True, progress=True, add_undo=True):
  function selectByIdx (line 118) | def selectByIdx(self, rowIdxs):
  function unselectByIdx (line 123) | def unselectByIdx(self, rowIdxs):
  function gatherBy (line 128) | def gatherBy(self, func, gerund='gathering'):
  function selectedRows (line 139) | def selectedRows(self):
  function onlySelectedRows (line 146) | def onlySelectedRows(self):
  function someSelectedRows (line 153) | def someSelectedRows(self):
  function nSelectedRows (line 165) | def nSelectedRows(self):
  function deleteSelected (line 171) | def deleteSelected(self):
  function addUndoSelection (line 181) | def addUndoSelection(sheet):
  function selectToNextRow (line 187) | def selectToNextRow(vs, func, reverse=False, msg='no selected row'):

FILE: visidata/settings.py
  class SettingsMgr (line 15) | class SettingsMgr(collections.OrderedDict):
    method __init__ (line 16) | def __init__(self):
    method __hash__ (line 20) | def __hash__(self):
    method __eq__ (line 23) | def __eq__(self, other):
    method objname (line 26) | def objname(self, obj):
    method getobj (line 46) | def getobj(self, objname):
    method unset (line 50) | def unset(self, k, obj='default'):
    method set (line 56) | def set(self, k, v, obj):
    method setdefault (line 63) | def setdefault(self, k, v):
    method _mappings (line 67) | def _mappings(self, obj):
    method _get (line 87) | def _get(self, key, obj=None):
    method iter (line 95) | def iter(self, obj=None):
    method iterall (line 107) | def iterall(self):
    method resetToDefaults (line 112) | def resetToDefaults(self):
  class Command (line 123) | class Command:
    method __init__ (line 124) | def __init__(self, longname, execstr, helpstr='', module='', replay=Tr...
  class Option (line 134) | class Option:
    method __init__ (line 135) | def __init__(self, name, value, description='', module='', help=''):
    method __str__ (line 146) | def __str__(self):
    method __eq__ (line 149) | def __eq__(self, other):
  class OptionsObject (line 154) | class OptionsObject:
    method __init__ (line 156) | def __init__(self, mgr, obj=None):
    method keys (line 161) | def keys(self, obj=None):
    method _get (line 166) | def _get(self, k, obj=None):
    method _set (line 174) | def _set(self, k, v, obj=None, helpstr='', module=None):
    method is_set (line 181) | def is_set(self, k, obj=None):
    method get (line 186) | def get(self, optname, default=None):
    method getobj (line 193) | def getobj(self, optname, obj=None):
    method getdefault (line 197) | def getdefault(self, optname):
    method getonly (line 200) | def getonly(self, optname, obj, default):
    method set (line 209) | def set(self, optname, value, obj='global', cmdlog=True):
    method unset (line 238) | def unset(self, optname, obj=None):
    method add_option_to_cmdlogs (line 247) | def add_option_to_cmdlogs(self, obj, optname, value='', longname='set-...
    method resetToDefaults (line 266) | def resetToDefaults(self):
    method setdefault (line 271) | def setdefault(self, optname, value, helpstr, module):
    method getall (line 274) | def getall(self, prefix=''):
    method __getattr__ (line 280) | def __getattr__(self, optname):      # options.foo
    method __setattr__ (line 284) | def __setattr__(self, optname, value):   # options.foo = value
    method __getitem__ (line 288) | def __getitem__(self, optname):      # options[optname]
    method __setitem__ (line 294) | def __setitem__(self, optname, value):   # options[optname] = value
  function optalias (line 307) | def optalias(vd, altname, optname, val=None):
  function _resolve_optalias (line 313) | def _resolve_optalias(vd, optname, optval):
  function option (line 323) | def option(vd, name, default, description, replay=False, sheettype=BaseS...
  function theme_option (line 342) | def theme_option(vd, name, *args, **kwargs):
  function addCommand (line 350) | def addCommand(cls, keystrokes, longname, execstr, helpstr='', replay=Tr...
  function removeCommand (line 366) | def removeCommand(cls, keystrokes, longname):
  function _command (line 376) | def _command(cls, binding, longname, helpstr, **kwargs):
  function bindkey (line 388) | def bindkey(vd, keystrokes, longname, obj='BaseSheet'):
  function unbindkey (line 393) | def unbindkey(vd, keystrokes, obj='BaseSheet'):
  function bindkey (line 400) | def bindkey(cls, keystrokes, longname):
  function unbindkey (line 409) | def unbindkey(cls, keystrokes):
  function getCommand (line 415) | def getCommand(sheet, cmd):
  function loadConfigFile (line 432) | def loadConfigFile(vd, fn=''):
  function addOptions (line 453) | def addOptions(parser):
  function config_file (line 465) | def config_file(vd):
  function cache_dir (line 474) | def cache_dir(vd):
  function data_dir (line 479) | def data_dir(vd):
  function loadConfigAndPlugins (line 484) | def loadConfigAndPlugins(vd, args=AttrDict()):
  function importModule (line 537) | def importModule(vd, pkgname, symbols=[]):
  function importSubmodules (line 552) | def importSubmodules(vd, pkgname):
  function importExternal (line 562) | def importExternal(vd, modname, pipmodname=''):
  function requireOptions (line 573) | def requireOptions(vd, *args, help=''):
  function setPersistentOptions (line 589) | def setPersistentOptions(vd, **kwargs):

FILE: visidata/sheets.py
  function _splitcell (line 32) | def _splitcell(sheet, s, width=0, maxheight=1):
  class Colorizer (line 52) | class Colorizer:
    method __init__ (line 58) | def __init__(self, precedence:int, coloropt:str, func=lambda s,c,r,v: ...
  class RowColorizer (line 63) | class RowColorizer(Colorizer):
    method func (line 64) | def func(self, s, c, r, v):
  class ColumnColorizer (line 67) | class ColumnColorizer(Colorizer):
    method func (line 68) | def func(self, s, c, r, v):
  class CellColorizer (line 71) | class CellColorizer(Colorizer):
    method func (line 72) | def func(self, s, c, r, v):
  class RecursiveExprException (line 76) | class RecursiveExprException(Exception):
  class LazyComputeRow (line 79) | class LazyComputeRow:
    method __init__ (line 81) | def __init__(self, sheet, row, col=None, **kwargs):
    method _lcm (line 91) | def _lcm(self):
    method __iter__ (line 97) | def __iter__(self):
    method keys (line 104) | def keys(self):
    method __str__ (line 107) | def __str__(self):
    method as_dict (line 110) | def as_dict(self):
    method __getattr__ (line 113) | def __getattr__(self, k):
    method __getitem__ (line 116) | def __getitem__(self, colid):
  class BasicRow (line 146) | class BasicRow(collections.defaultdict):
    method __init__ (line 147) | def __init__(self, *args):
    method __bool__ (line 149) | def __bool__(self):
  class TableSheet (line 152) | class TableSheet(BaseSheet):
    method help_title (line 161) | def help_title(self):
    method __init__ (line 180) | def __init__(self, *names, rows=UNLOADED, **kwargs):
    method topRowIndex (line 205) | def topRowIndex(self):
    method topRowIndex (line 209) | def topRowIndex(self, v):
    method addColorizer (line 213) | def addColorizer(self, c):
    method removeColorizer (line 218) | def removeColorizer(self, c):
    method classColorizers (line 223) | def classColorizers(self) -> list:
    method _colorize (line 235) | def _colorize(self, col, row, value=None) -> ColorAttr:
    method addRow (line 249) | def addRow(self, row, index=None):
    method newRow (line 259) | def newRow(self):
    method colsByName (line 264) | def colsByName(self):
    method column (line 269) | def column(self, colname):
    method recalc (line 273) | def recalc(self):
    method reload (line 279) | def reload(self):
    method beforeLoad (line 292) | def beforeLoad(self):
    method resetCols (line 295) | def resetCols(self):
    method loader (line 305) | def loader(self):
    method _iterloader (line 313) | def _iterloader(self):
    method iterload (line 323) | def iterload(self):
    method loadStart (line 328) | def loadStart(self):
    method loadSome (line 331) | def loadSome(self):
    method afterLoad (line 341) | def afterLoad(self):
    method iterrows (line 347) | def iterrows(self, gerund='iterating'):
    method __iter__ (line 361) | def __iter__(self):
    method __copy__ (line 366) | def __copy__(self):
    method bottomRowIndex (line 392) | def bottomRowIndex(self):
    method bottomRowIndex (line 396) | def bottomRowIndex(self, newidx):
    method rowHeight (line 400) | def rowHeight(self):
    method __deepcopy__ (line 404) | def __deepcopy__(self, memo):
    method __str__ (line 410) | def __str__(self):
    method __repr__ (line 413) | def __repr__(self):
    method currow (line 417) | def currow(self):
    method evalExpr (line 420) | def evalExpr(self, expr:str, row=None, col=None, **kwargs):
    method rowid (line 430) | def rowid(self, row):
    method nScreenRows (line 435) | def nScreenRows(self):
    method nHeaderRows (line 443) | def nHeaderRows(self):
    method nFooterRows (line 448) | def nFooterRows(self):
    method cursorCol (line 453) | def cursorCol(self):
    method cursorRow (line 459) | def cursorRow(self):
    method visibleRows (line 465) | def visibleRows(self):  # onscreen rows
    method visibleCols (line 470) | def visibleCols(self):  # non-hidden cols
    method keyCols (line 475) | def keyCols(self):
    method availCols (line 480) | def availCols(self):
    method availColnames (line 485) | def availColnames(self):
    method cursorColIndex (line 490) | def cursorColIndex(self):
    method nonKeyVisibleCols (line 498) | def nonKeyVisibleCols(self):
    method numericCols (line 503) | def numericCols(self):
    method keyColNames (line 508) | def keyColNames(self):
    method keyColNames (line 513) | def keyColNames(self, v):  #2122
    method cursorCell (line 520) | def cursorCell(self):
    method cursorDisplay (line 525) | def cursorDisplay(self):
    method cursorFullDisplay (line 530) | def cursorFullDisplay(self):
    method cursorTypedValue (line 535) | def cursorTypedValue(self):
    method cursorValue (line 540) | def cursorValue(self):
    method getTypedRow (line 544) | def getTypedRow(self, rownum):
    method statusLine (line 548) | def statusLine(self):
    method nRows (line 555) | def nRows(self):
    method nCols (line 560) | def nCols(self):
    method nVisibleCols (line 565) | def nVisibleCols(self):
    method cursorDown (line 569) | def cursorDown(self, n=1):
    method cursorRight (line 573) | def cursorRight(self, n=1):
    method addColumn (line 577) | def addColumn(self, *cols, index=None):
    method addColumnAtCursor (line 609) | def addColumnAtCursor(self, *cols):
    method setColNames (line 624) | def setColNames(self, rows):
    method setKeys (line 628) | def setKeys(self, cols):
    method unsetKeys (line 639) | def unsetKeys(self, cols):
    method rowkey (line 645) | def rowkey(self, row):
    method rowname (line 649) | def rowname(self, row):
    method checkCursor (line 653) | def checkCursor(self):
    method adjustColLayout (line 682) | def adjustColLayout(self):
    method calcColLayout (line 719) | def calcColLayout(self):
    method calcSingleColLayout (line 739) | def calcSingleColLayout(self, col:Column, vcolidx:int, x:int=0, minCol...
    method drawColHeader (line 768) | def drawColHeader(self, scr, y, h, vcolidx):
    method isVisibleIdxKey (line 831) | def isVisibleIdxKey(self, vcolidx):
    method allAggregators (line 836) | def allAggregators(self):
    method draw (line 846) | def draw(self, scr):
    method calc_height (line 931) | def calc_height(self, row, displines=None, isNull=None, maxheight=1):
    method drawRow (line 963) | def drawRow(self, scr, row, rowidx, ybase, rowcattr: ColorAttr, maxhei...
    method incremented_colname (line 1080) | def incremented_colname(self):
  class SequenceSheet (line 1092) | class SequenceSheet(Sheet):
    method setCols (line 1094) | def setCols(self, headerrows):
    method newRow (line 1103) | def newRow(self):
    method addRow (line 1106) | def addRow(self, row, index=None):
    method optlines (line 1114) | def optlines(self, it, optname):
    method loader (line 1122) | def loader(self):
  function _evalcontexts (line 1144) | def _evalcontexts(vd):
  function replace (line 1150) | def replace(vd, vs):
  function remove (line 1157) | def remove(vd, vs):
  function push (line 1169) | def push(vd, vs, pane=0, load=True):
  function quit (line 1199) | def quit(vd, *sheets):
  function confirmQuit (line 1220) | def confirmQuit(vs, verb='quit'):
  function preloadHook (line 1230) | def preloadHook(sheet):
  function newSheet (line 1238) | def newSheet(vd, name, ncols, **kwargs):
  function quitAndReleaseMemory (line 1245) | def quitAndReleaseMemory(vs):
  function splitPane (line 1259) | def splitPane(sheet, pct=None):
  function async_deepcopy (line 1270) | def async_deepcopy(sheet, rowlist):
  function reload_or_replace (line 1281) | def reload_or_replace(sheet):
  function formatter_enum (line 1348) | def formatter_enum(col, fmtdict):

FILE: visidata/shell.py
  function popen (line 25) | def popen(vd, *args, **kwargs):
  function killLeftoverProcesses (line 32) | def killLeftoverProcesses(vd):
  function guess_dir (line 39) | def guess_dir(vd, p):
  function currentDirSheet (line 45) | def currentDirSheet(p):
  function exec_shell (line 50) | def exec_shell(*args):
  function open_dir (line 59) | def open_dir(vd, p):
  function open_fdir (line 69) | def open_fdir(vd, p):
  function addShellColumns (line 73) | def addShellColumns(vd, cmd, sheet, curcol=None):
  class ColumnShell (line 81) | class ColumnShell(Column):
    method __init__ (line 82) | def __init__(self, name, cmd=None, curcol=None, **kwargs):
    method calcValue (line 88) | def calcValue(self, row):
  class DirSheet (line 105) | class DirSheet(Sheet):
    method colorOwner (line 157) | def colorOwner(sheet, col, row, val):
    method moveFile (line 170) | def moveFile(self, row, newparent):
    method renameFile (line 184) | def renameFile(self, row, val):
    method removeFile (line 190) | def removeFile(self, path):
    method commitDeleteRow (line 199) | def commitDeleteRow(self, r):
    method newRow (line 202) | def newRow(self):
    method iterload (line 205) | def iterload(self):
    method preloadHook (line 237) | def preloadHook(self):
    method restat (line 241) | def restat(self):
    method putChanges (line 245) | def putChanges(self):
    method getDefaultSaveName (line 253) | def getDefaultSaveName(sheet):
  class FileListSheet (line 257) | class FileListSheet(DirSheet):
    method iterload (line 259) | def iterload(self):
  function inputShell (line 265) | def inputShell(vd):
  function _openPreview (line 295) | def _openPreview(sheet, p):
  function previewFile (line 303) | def previewFile(sheet, p):
  function checkCursor (line 318) | def checkCursor(sheet):
  function copy_files (line 336) | def copy_files(sheet, paths, dest):

FILE: visidata/sidebar.py
  class AddedHelp (line 21) | class AddedHelp:
    method __init__ (line 23) | def __init__(self, text:Union[str,'HelpPane'], title='', help_flag=''):
    method __enter__ (line 30) | def __enter__(self):
    method __exit__ (line 36) | def __exit__(self, *args):
  function formatter_helpstr (line 43) | def formatter_helpstr(sheet):
  function default_sidebar (line 49) | def default_sidebar(sheet):
  function cycleSidebar (line 57) | def cycleSidebar(vd, n:int=1):
  function help_sidebars (line 70) | def help_sidebars(sheet) -> 'list[Callable[[], tuple[str,str]]]':
  function sidebarStatus (line 80) | def sidebarStatus(vd) -> str:
  function recentStatusMessages (line 91) | def recentStatusMessages(vd) -> str:
  function drawSidebar (line 114) | def drawSidebar(vd, scr, sheet):
  function drawBox (line 136) | def drawBox(vd, scr, x, y, w, h, cattr, bottom=True):
  function drawSidebarText (line 150) | def drawSidebarText(sheet, scr, text:Union[None,str,'HelpPane'], title:s...
  class SidebarSheet (line 222) | class SidebarSheet(TextSheet):

FILE: visidata/sort.py
  function orderBy (line 8) | def orderBy(sheet, *cols, reverse=False, change_column=False, save_cmd_i...
  class Reversor (line 53) | class Reversor:
    method __init__ (line 54) | def __init__(self, obj):
    method __eq__ (line 57) | def __eq__(self, other):
    method __lt__ (line 60) | def __lt__(self, other):
  function order_string (line 63) | def order_string(sheet):
  function order_from_string (line 68) | def order_from_string(sheet, s):
  function edit_ordering (line 80) | def edit_ordering(ordering, col, reverse):
  function ordering (line 102) | def ordering(sheet) -> 'list[tuple[Column, bool]]':
  function sortkey (line 112) | def sortkey(sheet, r, ordering:'list[tuple[Column, bool]]'=[]):
  function sort (line 123) | def sort(self):
  function _sort_order (line 148) | def _sort_order(col, srccol):

FILE: visidata/statusbar.py
  function ancestors (line 35) | def ancestors(sheet):
  function sheetlist (line 42) | def sheetlist(sheet):
  function _updateStatusBeforeExec (line 67) | def _updateStatusBeforeExec(sheet, cmd, args, ks):
  function statuses (line 78) | def statuses(vd):
  function statusHistory (line 83) | def statusHistory(vd):
  function getStatusSource (line 87) | def getStatusSource(vd) -> str:
  function printStatus (line 92) | def printStatus(vd, *args, priority=0, source=None):
  function status (line 102) | def status(vd, *args, priority=0):
  function addToStatusHistory (line 118) | def addToStatusHistory(vd, *args, priority=0, source=None):
  function error (line 129) | def error(vd, *args):
  function fail (line 135) | def fail(vd, *args):
  function warning (line 141) | def warning(vd, *args):
  function aside (line 146) | def aside(vd, *args, priority=0):
  function debug (line 151) | def debug(vd, *args, **kwargs):
  function composeStatus (line 157) | def composeStatus(msgparts, n=1):
  function leftStatus (line 165) | def leftStatus(sheet):
  function drawLeftStatus (line 171) | def drawLeftStatus(vd, scr, vs):
  function rightStatus (line 198) | def rightStatus(vd, sheet):
  function keystrokeStatus (line 204) | def keystrokeStatus(vs):
  function threadStatus (line 212) | def threadStatus(vs) -> str:
  function modifiedStatus (line 227) | def modifiedStatus(sheet):
  function selectedStatus (line 235) | def selectedStatus(sheet):
  function selectedStatus (line 240) | def selectedStatus(sheet):
  function drawRightStatus (line 245) | def drawRightStatus(vd, scr, vs):
  class StatusSheet (line 264) | class StatusSheet(Sheet):
    method reload (line 279) | def reload(self):
  function statusHistorySheet (line 284) | def statusHistorySheet(vd):

FILE: visidata/stored_list.py
  class StoredList (line 7) | class StoredList(list):
    method __init__ (line 9) | def __init__(self, *args, name:str='', **kwargs):
    method path (line 14) | def path(self):
    method reload (line 22) | def reload(self):
    method append (line 38) | def append(self, v):

FILE: visidata/tests/conftest.py
  function curses_setup (line 6) | def curses_setup():
  function mock_screen (line 18) | def mock_screen():

FILE: visidata/tests/test_cliptext.py
  class TestClipText (line 8) | class TestClipText:
    method test_dispwidth (line 14) | def test_dispwidth(self, s, dispw):
    method test_clipstr (line 47) | def test_clipstr(self, s, w, clippeds, clippedw):
    method test_clipstr_wide_truncator (line 75) | def test_clipstr_wide_truncator(self, s, w, clippeds, clippedw):
    method test_clipstr_empty_truncator (line 101) | def test_clipstr_empty_truncator(self, s, w, clippeds, clippedw):
    method test_clipstr_unprintable (line 114) | def test_clipstr_unprintable(self, s, w, truncator, clippeds, clippedw):
    method test_clipstr_start (line 133) | def test_clipstr_start(self, s, w, clippeds, clippedw):
    method test_clipstr_start_truncator (line 151) | def test_clipstr_start_truncator(self, s, w, clippeds, clippedw):
    method test_clipstr_middle (line 187) | def test_clipstr_middle(self, s, w, clippeds, clippedw):
    method test_truncate_markup_middle (line 257) | def test_truncate_markup_middle(self, s, dispw, clipped):
    method test_wraptext_color_spans_lines (line 286) | def test_wraptext_color_spans_lines(self, text, width, expected):
    method test_wraptext_escaped_literals (line 300) | def test_wraptext_escaped_literals(self, text, width, expected):

FILE: visidata/tests/test_commands.py
  function isTestableCommand (line 42) | def isTestableCommand(longname, cmdlist):
  class TestCommands (line 130) | class TestCommands:
    method test_baseCommands (line 132) | def test_baseCommands(self, mock_screen):
    method runOneTest (line 175) | def runOneTest(self, mock_screen, longname):

FILE: visidata/tests/test_completer.py
  class TestCompleteExpr (line 4) | class TestCompleteExpr:
    method test_completer (line 5) | def test_completer(self):

FILE: visidata/tests/test_date.py
  class TestVisidataDate (line 7) | class TestVisidataDate:
    method test_date (line 8) | def test_date(self):  #1507

FILE: visidata/tests/test_edittext.py
  class TestEditText (line 8) | class TestEditText:
    method setUp (line 10) | def setUp(self):
    method test_keys (line 50) | def test_keys(self, mock_screen, keys, result, kwargs):

FILE: visidata/tests/test_features.py
  function pytest_generate_tests (line 4) | def pytest_generate_tests(metafunc):
  function test_feature (line 25) | def test_feature(mock_screen, testfunc):

FILE: visidata/tests/test_fixed_width.py
  class TestColumnize (line 4) | class TestColumnize:
    method test_basic (line 5) | def test_basic(self):
    method test_data_with_internal_spaces (line 10) | def test_data_with_internal_spaces(self):  #2265
    method test_empty (line 25) | def test_empty(self):
    method test_single_column (line 28) | def test_single_column(self):

FILE: visidata/tests/test_keystrokes.py
  function accumulate_keystrokes (line 5) | def accumulate_keystrokes(keys):
  function setup_custom_prefixes (line 36) | def setup_custom_prefixes():
  function test_prefix_keystrokes (line 64) | def test_prefix_keystrokes(keys, expected_outcome, expected_keystrokes):

FILE: visidata/tests/test_menu.py
  class TestMenu (line 6) | class TestMenu:
    method test_menuitems (line 7) | def test_menuitems(self):

FILE: visidata/tests/test_parsepos.py
  function test_parsePos (line 4) | def test_parsePos():

FILE: visidata/tests/test_path.py
  class TestVisidataPath (line 7) | class TestVisidataPath:
    method test_withName (line 9) | def test_withName(self):
    method test_opentwice (line 33) | def test_opentwice(self):
    method test_iterdir_yields_visidata_paths (line 40) | def test_iterdir_yields_visidata_paths(self):  # #2188
    method test_name_returns_full_filename (line 45) | def test_name_returns_full_filename(self):  # #2188
    method test_repeatfile_bytesiowrapper (line 51) | def test_repeatfile_bytesiowrapper(self):  # #2829

FILE: visidata/text_source.py
  function regex_flags (line 9) | def regex_flags(sheet):
  class FilterFile (line 14) | class FilterFile:
    method __init__ (line 15) | def __init__(self, fp, regex:str, regex_flags:int=0):
    method readline (line 20) | def readline(self) -> str:
    method __getattr__ (line 27) | def __getattr__(self, k):
    method __iter__ (line 30) | def __iter__(self):
    method __next__ (line 33) | def __next__(self):
    method __enter__ (line 39) | def __enter__(self):
    method __exit__ (line 42) | def __exit__(self, *args, **kwargs):
  function open_text_source (line 47) | def open_text_source(sheet, **kwargs):

FILE: visidata/textsheet.py
  class TextSheet (line 16) | class TextSheet(Sheet):
    method iterload (line 25) | def iterload(self):
    method readlines (line 28) | def readlines(self, source):
    method sysopen (line 38) | def sysopen(sheet, linenum=0):
  class ErrorSheet (line 58) | class ErrorSheet(TextSheet):
    method sysopen_error (line 71) | def sysopen_error(self, col, row):
    method reload (line 86) | def reload(self):
  class ErrorCellSheet (line 90) | class ErrorCellSheet(ErrorSheet):
  class ErrorsSheet (line 102) | class ErrorsSheet(Sheet):
    method reload (line 107) | def reload(self):
    method openRow (line 110) | def openRow(self, row):
  function allErrorsSheet (line 114) | def allErrorsSheet(self):
  function recentErrorsSheet (line 118) | def recentErrorsSheet(self):

FILE: visidata/theme.py
  function run (line 12) | def run(vd, *args, **kwargs):
  function set_theme (line 20) | def set_theme(obj, theme=''):

FILE: visidata/threads.py
  class QueuedFunc (line 27) | class QueuedFunc:
    method __init__ (line 28) | def __init__(self, func, args, kwargs, readonly=False):
    method _run_sync (line 36) | def _run_sync(self):
    method _run (line 39) | def _run(self):
  function _queueFunc (line 44) | def _queueFunc(vd, func, *args, _readonly=False, **kwargs):
  function _runToCapacity (line 52) | def _runToCapacity(vd):
  function asynccache (line 61) | def asynccache(keyfunc=lambda *args, **kwargs: str(args)+str(kwargs)):
  class _Progress (line 77) | class _Progress:
    method __init__ (line 78) | def __init__(self, iterable=None, gerund="", total=None, sheet=None):
    method __enter__ (line 91) | def __enter__(self):
    method addProgress (line 96) | def addProgress(self, n):
    method __exit__ (line 101) | def __exit__(self, exc_type, exc_val, tb):
    method __iter__ (line 105) | def __iter__(self):
  function Progress (line 112) | def Progress(vd, iterable=None, gerund="", total=None, sheet=None):
  function cancelThread (line 124) | def cancelThread(vd, *threads, exception=EscapeException):
  class ThreadsSheet (line 132) | class ThreadsSheet(Sheet):
    method reload (line 142) | def reload(self):
    method openRow (line 145) | def openRow(self, row):
  function elapsed_s (line 152) | def elapsed_s(t):
  function checkMemoryUsage (line 157) | def checkMemoryUsage(vd):
  function progressMade (line 190) | def progressMade(self):
  function progressTotal (line 194) | def progressTotal(self):
  function progressPct (line 199) | def progressPct(sheet):
  function _annotate_thread (line 207) | def _annotate_thread(t, endTime=None):
  function execSync (line 219) | def execSync(vd, func, *args, sheet=None, **kwargs):
  function execAsync (line 227) | def execAsync(vd, func, *args, **kwargs):
  function _toplevelTryFunc (line 264) | def _toplevelTryFunc(func, *args, **kwargs):
  function asyncignore (line 290) | def asyncignore(func):
  function asyncsingle (line 302) | def asyncsingle(func):
  function asyncsingle_queue (line 324) | def asyncsingle_queue(func):
  function unfinishedThreads (line 346) | def unfinishedThreads(self):
  function sync (line 352) | def sync(self, *joiningThreads):
  function open_pyprof (line 378) | def open_pyprof(vd, p):
  function toggleProfiling (line 384) | def toggleProfiling(vd):
  class ThreadProfiler (line 398) | class ThreadProfiler:
    method __init__ (line 399) | def __init__(self, thread):
    method __enter__ (line 403) | def __enter__(self):
    method __exit__ (line 411) | def __exit__(self, exc_type, exc_val, tb):
  class ProfileSheet (line 428) | class ProfileSheet(Sheet):
    method reload (line 454) | def reload(self):
    method openRow (line 468) | def openRow(self, row):
    method openCell (line 474) | def openCell(self, col, row):
  class ProfileStatsSheet (line 482) | class ProfileStatsSheet(Sheet):
    method reload (line 494) | def reload(self):
    method openRow (line 497) | def openRow(self, row):
  function codestr (line 500) | def codestr(code):
  function allThreadsSheet (line 507) | def allThreadsSheet(self):
  function cancel_sheet (line 511) | def cancel_sheet(sheet):

FILE: visidata/tuiwin.py
  function subwindow (line 7) | def subwindow(vd, scr, x, y, w, h):
  function getrootxy (line 15) | def getrootxy(vd, scr):  # like scr.getparyx() but for all ancestor scrs

FILE: visidata/type_currency.py
  function currency (line 10) | def currency(*args):
  function displayer_currency (line 18) | def displayer_currency(col, dw, width=None):

FILE: visidata/type_date.py
  function date_parse (line 6) | def date_parse(vd):
  class date (line 34) | class date(datetime.datetime):
    method __new__ (line 37) | def __new__(cls, *args, **kwargs):
    method __lt__ (line 59) | def __lt__(self, b):
    method __gt__ (line 64) | def __gt__(self, b):
    method __le__ (line 69) | def __le__(self, b):
    method __ge__ (line 74) | def __ge__(self, b):
    method __eq__ (line 79) | def __eq__(self, b):
    method __str__ (line 84) | def __str__(self):
    method __hash__ (line 87) | def __hash__(self):
    method __float__ (line 90) | def __float__(self):
    method __radd__ (line 93) | def __radd__(self, n):
    method __add__ (line 96) | def __add__(self, n):
    method __sub__ (line 102) | def __sub__(self, n):
  class datedelta (line 111) | class datedelta(datetime.timedelta):
    method __float__ (line 112) | def __float__(self):

FILE: visidata/type_floatsi.py
  function SIFormatter (line 7) | def SIFormatter(vd, fmtstr, val):
  function floatsi (line 21) | def floatsi(*args):

FILE: visidata/undo.py
  function isUndoableCommand (line 12) | def isUndoableCommand(longname):
  function addUndo (line 19) | def addUndo(vd, undofunc, *args, **kwargs):
  function undo (line 39) | def undo(vd, sheet):
  function redo (line 65) | def redo(vd, sheet):
  function undoAttrFunc (line 72) | def undoAttrFunc(objs, attrname):
  class Fanout (line 81) | class Fanout(list):
    method __getattr__ (line 83) | def __getattr__(self, k):
    method __setattr__ (line 86) | def __setattr__(self, k, v):
    method __call__ (line 91) | def __call__(self, *args, **kwargs):
  function undoAttrCopyFunc (line 95) | def undoAttrCopyFunc(objs, attrname):
  function addUndoSetValues (line 105) | def addUndoSetValues(vd, cols, rows):

FILE: visidata/utils.py
  class AlwaysDict (line 11) | class AlwaysDict(dict):
    method __init__ (line 13) | def __init__(self, val, **kwargs):
    method __getitem__ (line 17) | def __getitem__(self, k):
  class AttrDict (line 20) | class AttrDict(dict):
    method __getattr__ (line 22) | def __getattr__(self, k):
    method __setattr__ (line 33) | def __setattr__(self, k, v):
    method __dir__ (line 36) | def __dir__(self):
  class DefaultAttrDict (line 40) | class DefaultAttrDict(dict):
    method __getattr__ (line 42) | def __getattr__(self, k):
    method __setattr__ (line 49) | def __setattr__(self, k, v):
    method __dir__ (line 52) | def __dir__(self):
  class classproperty (line 58) | class classproperty(property):
    method __get__ (line 59) | def __get__(self, cls, obj):
  function moveListItem (line 63) | def moveListItem(L, fromidx, toidx):
  function setitem (line 72) | def setitem(r, i, v):  # function needed for use in lambda
  function getitem (line 76) | def getitem(o, k, default=None):
  function getitemdef (line 79) | def getitemdef(o, k, default=None):
  function getattrdeep (line 86) | def getattrdeep(obj, attr, *default, getter=getattr):
  function setattrdeep (line 110) | def setattrdeep(obj, attr, val, getter=getattr, setter=setattr):
  function getitemdeep (line 131) | def getitemdeep(obj, k, *default):
  function setitemdeep (line 139) | def setitemdeep(obj, k, val):
  function namedlist (line 143) | def namedlist(objname, fieldnames):
  class ExplodingMock (line 175) | class ExplodingMock:
    method __init__ (line 177) | def __init__(self, msg):
    method __getattr__ (line 180) | def __getattr__(self, k):
    method __bool__ (line 183) | def __bool__(self):
  class MissingAttrFormatter (line 187) | class MissingAttrFormatter(string.Formatter):
    method get_value (line 189) | def get_value(self, key, args, kwargs):
    method get_field (line 195) | def get_field(self, field_name, args, kwargs):
    method format_field (line 201) | def format_field(self, value, format_spec):
  function ScopedSetattr (line 211) | def ScopedSetattr(obj, attrname, val):
  function colname_letters (line 219) | def colname_letters(num):

FILE: visidata/vdobj.py
  function asyncthread (line 16) | def asyncthread(func):
  class VisiData (line 27) | class VisiData(visidata.Extensible):
    method global_api (line 31) | def global_api(cls, func):
    method __init__ (line 39) | def __init__(self):
    method cursesEnabled (line 54) | def cursesEnabled(self):
    method sheetstack (line 57) | def sheetstack(self, pane=0):
    method stackedSheets (line 65) | def stackedSheets(self):
    method activeSheet (line 69) | def activeSheet(self):
    method activeStack (line 82) | def activeStack(self):
    method __copy__ (line 85) | def __copy__(self):
    method finalInit (line 89) | def finalInit(self):
    method init (line 94) | def init(cls, membername, initfunc, **kwargs):
    method clearCaches (line 103) | def clearCaches(self):
    method resetVisiData (line 107) | def resetVisiData(self):
    method get_wch (line 118) | def get_wch(self, scr):
    method drainPendingKeys (line 127) | def drainPendingKeys(self, scr):
    method getkeystroke (line 144) | def getkeystroke(self, scr, vs=None):
    method screenHeight (line 176) | def screenHeight(self):
    method screenWidth (line 180) | def screenWidth(self):
    method activeCommand (line 184) | def activeCommand(self):
    method activeCommand (line 194) | def activeCommand(self, value):

FILE: visidata/vendor/appdirs.py
  function user_data_dir (line 44) | def user_data_dir(appname=None, appauthor=None, version=None, roaming=Fa...
  function site_data_dir (line 99) | def site_data_dir(appname=None, appauthor=None, version=None, multipath=...
  function user_config_dir (line 165) | def user_config_dir(appname=None, appauthor=None, version=None, roaming=...
  function site_config_dir (line 209) | def site_config_dir(appname=None, appauthor=None, version=None, multipat...
  function user_cache_dir (line 264) | def user_cache_dir(appname=None, appauthor=None, version=None, opinion=T...
  function user_state_dir (line 321) | def user_state_dir(appname=None, appauthor=None, version=None, roaming=F...
  function user_log_dir (line 363) | def user_log_dir(appname=None, appauthor=None, version=None, opinion=True):
  class AppDirs (line 414) | class AppDirs(object):
    method __init__ (line 416) | def __init__(self, appname=None, appauthor=None, version=None,
    method user_data_dir (line 425) | def user_data_dir(self):
    method site_data_dir (line 430) | def site_data_dir(self):
    method user_config_dir (line 435) | def user_config_dir(self):
    method site_config_dir (line 440) | def site_config_dir(self):
    method user_cache_dir (line 445) | def user_cache_dir(self):
    method user_state_dir (line 450) | def user_state_dir(self):
    method user_log_dir (line 455) | def user_log_dir(self):
  function _get_win_folder_from_registry (line 462) | def _get_win_folder_from_registry(csidl_name):
  function _get_win_folder_with_ctypes (line 486) | def _get_win_folder_with_ctypes(csidl_name):
  function _get_win_folder_with_jna (line 512) | def _get_win_folder_with_jna(csidl_name):
  function _get_win_folder_from_environ (line 538) | def _get_win_folder_from_environ(csidl_name):

FILE: visidata/wrappers.py
  function isNullFunc (line 10) | def isNullFunc(sheet):
  class TypedWrapper (line 19) | class TypedWrapper:
    method __init__ (line 20) | def __init__(self, func, *args):
    method __bool__ (line 25) | def __bool__(self):
    method __len__ (line 28) | def __len__(self):
    method __repr__ (line 31) | def __repr__(self):
    method __str__ (line 34) | def __str__(self):
    method __lt__ (line 40) | def __lt__(self, x):
    method __add__ (line 44) | def __add__(self, x):
    method __radd__ (line 47) | def __radd__(self, x):
    method __hash__ (line 50) | def __hash__(self):
    method __eq__ (line 53) | def __eq__(self, x):
    method __iter__ (line 57) | def __iter__(self):
    method __next__ (line 60) | def __next__(self):
  class TypedExceptionWrapper (line 64) | class TypedExceptionWrapper(TypedWrapper):
    method __init__ (line 65) | def __init__(self, func, *args, exception=None):
    method __str__ (line 71) | def __str__(self):
    method __hash__ (line 74) | def __hash__(self):
    method __eq__ (line 77) | def __eq__(self, x):
  function forward (line 82) | def forward(wr):
  function wrmap (line 88) | def wrmap(func, iterable, *args):
  function wrapply (line 97) | def wrapply(func, *args, **kwargs):