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

visidata/apps/vgit/diff.py

@@ -0,0 +1,169 @@
+from visidata import vd, VisiData, ItemColumn, RowColorizer, AttrDict, Column
+
+from .gitsheet import GitSheet
+
+vd.option('git_diff_algo', 'minimal', 'algorithm to use for git diff')
+vd.theme_option('color_git_hunk_add', 'green', 'color for added hunk lines')
+vd.theme_option('color_git_hunk_del', 'red', 'color for deleted hunk lines')
+vd.theme_option('color_git_hunk_diff', 'yellow', 'color for hunk diffs')
+
+@VisiData.api
+def git_diff(vd, p, args):
+    return GitDiffSheet('git-diff', source=p, gitargs=args)
+
+def _parseStartCount(s):
+    sc = s.split(',')
+    if len(sc) == 2:
+        return sc
+    if len(sc) == 1:
+        return sc[0], 1
+
+
+class GitDiffSheet(GitSheet):
+    columns = [
+        ItemColumn('a_fn', width=0),
+        ItemColumn('fn', 'b_fn', width=30, hoffset=-28),
+        ItemColumn('a_lineno', type=int, width=0),
+        ItemColumn('lineno', 'b_lineno', type=int, width=8),
+        Column('count', width=10, getter=lambda c,r: c.sheet.hunkCount(r)),
+        ItemColumn('context'),
+        ItemColumn('lines', type=''.join),
+    ]
+
+    guide = '''# {sheet.cursorRow.a_fn}
+{sheet.cursorLines}'''
+
+    def hunkCount(self, row):
+        return f'-{row.a_count}/+{row.b_count}'
+
+    @property
+    def cursorLines(self):
+        r = ''
+        for line in self.cursorRow.lines[2:]:
+            if line.startswith('-'):
+                line = '[:git_hunk_del]' + line + '[/]'
+            elif line.startswith('+'):
+                line = '[:git_hunk_add]' + line + '[/]'
+
+            r += line + '\n'
+        r = r[4:]
+        return r
+
+    def iterload(self):
+        current_hunk = None
+
+        for line in self.git_lines('diff --patch --inter-hunk-context=2 --find-renames --no-color --no-prefix', *self.gitargs):
+            if line.startswith('diff'):
+                diff_started = True
+                continue
+            if not diff_started:
+                continue
+
+            if line.startswith('---'):
+                hunk_lines = [line]  # new file
+                leftfn = line[4:]
+            elif line.startswith('+++'):
+                hunk_lines.append(line)
+                rightfn = line[4:]
+            elif line.startswith('@@'):
+                hunk_lines.append(line)
+                _, linenums, context = line.split('@@')
+                leftlinenums, rightlinenums = linenums.split()
+                leftstart, leftcount = _parseStartCount(leftlinenums[1:])
+                rightstart, rightcount = _parseStartCount(rightlinenums[1:])
+                current_hunk = AttrDict(
+                    a_fn=leftfn,
+                    b_fn=rightfn,
+                    context=context,
+                    a_lineno=int(leftstart),
+                    a_count=0,
+                    b_lineno=int(rightstart),
+                    b_count=0,
+                    lines=hunk_lines
+                )
+                yield current_hunk
+                hunk_lines = hunk_lines[:2]  # keep file context only
+
+            elif line[0] in ' +-':
+                current_hunk.lines.append(line)
+                if line[0] == '+':
+                    current_hunk.a_count += 1
+                elif line[0] == '-':
+                    current_hunk.b_count += 1
+
+    def openRow(self, row):
+        return HunkViewer(f'{row.a_fn}:{row.a_lineno}', source=self.source, hunks=[row])
+
+
+class HunkViewer(GitSheet):
+    colorizers = [
+        RowColorizer(4, 'color_git_hunk_add', lambda s,c,r,v: r and r.old != r.new and r.old is None),
+        RowColorizer(4, 'color_git_hunk_del', lambda s,c,r,v: r and r.old != r.new and r.new is None),
+        RowColorizer(5, 'color_git_hunk_diff', lambda s,c,r,v: r and r.old != r.new and r.new is not None and r.old is not None),
+    ]
+    columns = [
+        ItemColumn('1', 'old', width=40),
+        ItemColumn('2', 'new', width=40),
+    ]
+
+    def draw(self, scr):
+        self.column('1').width=self.windowWidth//2-1
+        self.column('2').width=self.windowWidth//2-1
+        super().draw(scr)
+
+    def iterload(self):
+        nextDelIdx = None
+        for hunk in self.hunks:
+          for line in hunk.lines[3:]:  # diff without the patch headers
+            typech = line[0]
+            line = line[1:]
+            if typech == '-':  # deleted
+                yield AttrDict(hunk=hunk, type=typech, old=line)
+                if nextDelIdx is None:
+                    nextDelIdx = len(self.rows)-1
+            elif typech == '+':  # added
+                if nextDelIdx is not None:
+                    if nextDelIdx < len(self.rows):
+                        self.rows[nextDelIdx].new = line
+                        nextDelIdx += 1
+                        continue
+
+                yield AttrDict(hunk=hunk, type=typech, new=line)
+                nextDelIdx = None
+            elif typech == ' ':  # unchanged
+                yield AttrDict(hunk=hunk, type=typech, old=line, new=line)
+                nextDelIdx = None
+            else:
+                continue  # header
+
+
+HunkViewer.addCommand('2', 'git-apply-hunk', 'source.git_apply(cursorRow.hunk, "--cached"); reload()', 'apply this hunk to the index and move to the next hunk')
+HunkViewer.addCommand('1', 'git-remove-hunk', 'source.git_apply(cursorRow.hunk, "--reverse"); reload()', 'remove this hunk from staging')
+HunkViewer.addCommand('Enter', 'git-skip-hunk', 'hunks.pop(0); reload()', 'move to the next hunk without applying this hunk')
+HunkViewer.addCommand('d', 'delete-line', 'source[7].pop(cursorRow[3]); reload()', 'delete a line from the patch')
+
+#HunksSheet.addCommand('g^J', 'git-diff-selected', 'vd.push(HunkViewer(selectedRows or rows, source=sheet))', 'view the diffs for the selected hunks (or all hunks)')
+
+@GitDiffSheet.api
+def git_apply(sheet, row, *args):
+    sheet.git('apply -p0 -', *args, _in='\n'.join(row.lines)+'\n')
+
+    c = sheet.hunkCount(row)
+    vd.status(f'applied hunk ({c})')
+    sheet.reload()
+
+
+#DiffSheet.addCommand('[', '', 'cursorRowIndex = findDiffRow(cursorCol.refnum, cursorRowIndex, -1)', 'go to previous diff')
+#DiffSheet.addCommand(']', '', 'cursorRowIndex = findDiffRow(cursorCol.refnum, cursorRowIndex, +1)', 'go to next diff')
+
+GitDiffSheet.addCommand('a', 'git-add-hunk', 'git_apply(cursorRow, "--cached")', 'apply this hunk to the index')
+
+vd.addMenuItems('''
+    Git > Stage > current hunk > git-add-hunk
+    Git > Stage > current hunk > git-add-hunk
+''')
+
+vd.addGlobals(
+    GitDiffSheet=GitDiffSheet,
+    HunkViewer=HunkViewer
+)

visidata/apps/vgit/gitsheet.py

@@ -0,0 +1,161 @@
+import io
+
+from visidata import AttrDict, vd, Path, asyncthread, Sheet
+
+
+class GitSheet(Sheet):
+    @property
+    def gitargstr(self):
+        return ' '.join(self.gitargs)
+
+    def git(self, subcmd, *args, **kwargs):
+        'For non-modifying commands; not logged except in debug mode'
+        sh = vd.importExternal('sh')
+        args = list(subcmd.split()) + list(args)
+        vd.debug('git ' + ' '.join(str(x) for x in args))
+        return sh.git(*args,
+                      _cwd=self.gitRootPath,
+                      **kwargs)
+
+    def loggit(self, subcmd, *args, **kwargs):
+        'Run git command with *args*, and post a status message.'
+        import sh
+        args = list(subcmd.split()) + list(args)
+        vd.warning('git ' + ' '.join(str(x) for x in args))
+        return sh.git(*args,
+                      _cwd=self.gitRootPath,
+                      **kwargs)
+
+    def git_all(self, *args, **kwargs):
+        'Return entire output of git command.'
+        sh = vd.importExternal('sh')
+        try:
+            vd.debug('git ' + ' '.join(str(x) for x in args))
+            out = self.git('--no-pager',
+                      *args,
+                      _decode_errors='replace',
+                      _bg_exc=False,
+                      **kwargs)
+        except sh.ErrorReturnCode as e:
+            vd.warning('git '+' '.join(str(x) for x in args), 'error=%s' % e.exit_code)
+            out = e.stdout
+
+        return out
+
+    def git_lines(self, subcmd, *args, **kwargs):
+        'Generator of stdout lines from given git command'
+        sh = vd.importExternal('sh')
+        err = io.StringIO()
+        args = list(subcmd.split()) + list(args)
+        try:
+            vd.debug('git ' + ' '.join(str(x) for x in args))
+            for line in self.git('--no-pager',
+                            *args,
+                            _decode_errors='replace',
+                            _iter=True,
+                            _bg_exc=False,
+                            _err=err,
+                            **kwargs):
+                yield line[:-1]  # remove EOL
+
+        except sh.ErrorReturnCode as e:
+            vd.warning('git '+' '.join(str(x) for x in args), 'error=%s' % e.exit_code)
+
+        errlines = err.getvalue().splitlines()
+        if errlines:
+            vd.warning('git stderr: ' + '\n'.join(errlines))
+
+
+    def git_iter(self, subcmd, *args, sep='\0', **kwargs):
+        'Generator of chunks of stdout from given git command *subcmd*, delineated by sep character.'
+        sh = vd.importExternal('sh')
+        import sh
+        err = io.StringIO()
+
+        args = list(subcmd.split()) + list(args)
+        bufsize = 512
+        chunks = []
+        try:
+            vd.debug('git ' + ' '.join(str(x) for x in args))
+            for data in self.git('--no-pager',
+                               *args,
+                               _decode_errors='replace',
+                               _out_bufsize=bufsize,
+                               _iter=True,
+                               _bg_exc=False,
+                               _err=err,
+                               **kwargs):
+                while True:
+                    i = data.find(sep)
+                    if i < 0:
+                        break
+                    chunks.append(data[:i])
+                    data = data[i+1:]
+                    yield ''.join(chunks)
+                    chunks.clear()
+
+                chunks.append(data)
+        except sh.ErrorReturnCode as e:
+            vd.warning('git '+' '.join(str(x) for x in args), 'error=%s' % e.exit_code)
+
+        if chunks:
+            yield ''.join(chunks)
+
+        errlines = err.getvalue().splitlines()
+        if errlines:
+            vd.warning('git stderr: ' + '\n'.join(errlines))
+
+    @asyncthread
+    def modifyGit(self, *args, **kwargs):
+        'Run git command that modifies the repo'
+        vd.warning('git ' + ' '.join(str(x) for x in args))
+        ret = self.git_all(*args, **kwargs)
+        vd.status(ret)
+
+        if isinstance(self.source, GitSheet):
+            self.source.reload()
+
+        self.reload()
+
+    @property
+    def gitRootSheet(self):
+        if isinstance(self.source, GitSheet):
+            return self.source.gitRootSheet
+        return self
+
+    def iterload(self):
+        for line in self.git_lines(*self.gitargs):
+            yield AttrDict(line=line)
+
+
+@GitSheet.lazy_property
+def gitRootPath(self):
+    'Return Path of git root (nearest ancestor directory with a .git/)'
+    def _getRepoPath(p):
+        'Return path at p or above which has .git subdir'
+        if p.joinpath('.git').exists():
+            return p
+        if str(p) in ['/','']:
+            return None
+        return _getRepoPath(p.resolve().parent)
+
+    p = _getRepoPath(self.gitRootSheet.source)
+    if p:
+       return p
+
+
+@GitSheet.lazy_property
+def branch(self):
+    return self.git('rev-parse', '--abbrev-ref', 'HEAD').strip()
+
+
+GitSheet.options.disp_note_none = ''
+GitSheet.options.disp_status_fmt = '{sheet.progressStatus}‹{sheet.branchStatus}› {sheet.name}| '
+
+GitSheet.addCommand('gi', 'git-exec', 'cmdstr=input("gi", type="git"); vd.push(GitSheet(cmdstr, gitargs=cmdstr.split()))', 'execute git command')
+
+GitSheet.addCommand('Alt+g', 'menu-git', 'pressMenu("Git")', '')
+
+vd.addMenuItems('''
+    Git > Execute command > git-exec
+''')

visidata/apps/vgit/grep.py

@@ -0,0 +1,37 @@
+from visidata import vd, VisiData, Path, ColumnItem, ESC
+
+from .gitsheet import GitSheet
+
+
+@VisiData.api
+def git_grep(vd, p, args):
+    return GitGrep(args[0], regex=args[0], source=p)
+
+
+class GitGrep(GitSheet):
+    rowtype = 'results' # rowdef: list(file, line, line_contents)
+    guide = '''
+        # vgit grep
+        Each row on this sheet is a line matching the regex pattern `{sheet.regex}` in the tracked files of the current directory.
+
+        - `Ctrl+O` to open _{sheet.cursorRow[0]}:{sheet.cursorRow[1]}_ in the system editor; saved changes will be reflected automatically.
+    '''
+    columns = [
+        ColumnItem('file', 0, help='filename of the match'),
+        ColumnItem('line', 1, help='line number within file'),
+        ColumnItem('text', 2, width=120, help='matching line of text'),
+    ]
+    nKeys = 2
+
+    def iterload(self):
+        tmp = (self.topRowIndex, self.cursorRowIndex)
+        for line in self.git_lines('grep', '--no-color', '-z', '--line-number', '--ignore-case', self.regex):
+#            line = line.replace(ESC+'[1;31m', '[:green]')
+#            line = line.replace(ESC+'[m', '[/]')
+            yield list(line.split('\0'))
+        self.topRowIndex, self.cursorRowIndex = tmp
+
+
+GitSheet.addCommand('g/', 'git-grep', 'rex=inputRegex("git grep: "); vd.push(GitGrep(rex, regex=rex, source=sheet))', 'find in all files in this repo')
+GitGrep.addCommand('Ctrl+O', 'sysopen-row', 'launchExternalEditorPath(Path(cursorRow[0]), linenum=cursorRow[1]); reload()', 'open this file in $EDITOR')
+GitGrep.bindkey('Enter', 'sysopen-row')

visidata/apps/vgit/log.py

@@ -0,0 +1,81 @@
+import functools
+
+from visidata import vd, VisiData, Column, ItemColumn, date, RowColorizer, asyncthread, Progress, AttrDict
+
+from .gitsheet import GitSheet
+
+
+@VisiData.api
+def git_log(vd, p, *args):
+    return GitLogSheet('git-log', source=p, gitargs=args)
+
+# rowdef: (commit_hash, refnames, author, author_date, body, notes)
+class GitLogSheet(GitSheet):
+    guide = '''
+# git log {sheet.gitargstr}
+{sheet.cursorRow.message}
+    '''
+    GIT_LOG_FORMAT = ['%H', '%D', '%an <%ae>', '%ai', '%B', '%N']
+    rowtype = 'commits'  # rowdef: AttrDict
+    defer = True
+    savesToSource = True
+    columns = [
+        ItemColumn('commitid', width=8),
+        ItemColumn('refnames', width=12),
+        ItemColumn('message', type=str.strip, setter=lambda c,r,v: c.sheet.git('commit --amend --no-edit --quiet --message', v), width=50),
+        ItemColumn('author', setter=lambda c,r,v: c.sheet.git('commit --amend --no-edit --quiet --author', v)),
+        ItemColumn('author_date', type=date, setter=lambda c,r,v: c.sheet.git('commit --amend --no-edit --quiet --date', v)),
+        ItemColumn('notes', setter=lambda c,r,v: c.sheet.git('notes add --force --message', v, r.commitid)),
+    ]
+    colorizers = [
+            RowColorizer(5, 'color_vgit_unpushed', lambda s,c,r,v: r and not s.inRemoteBranch(r.commitid)),
+    ]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    @functools.lru_cache()
+    def inRemoteBranch(self, commitid):
+        return self.git_all('branch -r --contains', commitid, _ok_code=[0, 1])
+
+    def iterload(self):
+        lines = self.git_iter('log --no-color -z', '--pretty=format:' + '%x1f'.join(self.GIT_LOG_FORMAT), *self.gitargs)
+        for record in Progress(tuple(lines)):
+            r = record.split('\x1f')
+            yield AttrDict(
+                commitid=r[0],
+                refnames=r[1],
+                author=r[2],
+                author_date=r[3],
+                message=r[4],
+                notes=r[5],
+            )
+
+    def openRow(self, row):
+        'open this commit'
+        return getCommitSheet(row[0][:7], self, row[0])
+
+    @asyncthread
+    def commit(self, path, adds, mods, dels):
+
+        assert not adds
+        assert not dels
+
+        for row, rowmods in mods.values():
+            for col, val in rowmods.values():
+                vd.callNoExceptions(col.putValue, row, val)
+
+        self.reload()
+        self.resetDeferredCommit()
+
+
+GitLogSheet.addCommand(None, 'delete-row', 'error("delete is not supported")')
+GitLogSheet.addCommand(None, 'add-row', 'error("commits cannot be added")')
+#GitLogSheet.addCommand('x', 'git-pick', 'git("cherry-pick", cursorRow.commitid)', 'cherry-pick this commit onto current branch')
+#GitLogSheet.addCommand('r', 'git-reset-here', 'git("update-ref", "refs/heads/"+source, cursorRow[0])', 'reset this branch to this commit')
+
+GitSheet.addCommand('', 'git-log', 'vd.push(git_log(gitRootPath, branch))', 'push log of current branch')
+
+vd.addMenuItems('''
+    Git > Open > log > git-log
+''')

visidata/apps/vgit/main.py

@@ -0,0 +1,55 @@
+'''
+# vgit: VisiData wrapper for git
+
+The syntax for vgit is the same as the syntax for git.
+By default, will pass the command to git verbatim, as quickly as possible.
+If vgit can provide an interactive interface for a particular subcommand,
+it will open the sheet returned by vd.git_<subcommand>(path, args).
+'''
+
+import os
+import sys
+
+
+def vgit_cli():
+    import visidata
+    from visidata import vd, Path
+
+    args = sys.argv[1:]
+    flDebug = '--debug' in args
+    if flDebug:
+        args.remove('--debug')
+
+    if not args:
+        args = ['help']
+
+    func = getattr(vd, 'git_'+args[0], None)
+    if func:
+        vd.loadConfigAndPlugins()
+        vd.status(visidata.__version_info__)
+        vd.domotd()
+        if flDebug:
+            vd.options.debug = True
+
+        rc = 0
+        try:
+            p = Path('.')
+            vs = func(p, args[1:])
+            if vs:
+                vd.run(vs)
+        except BrokenPipeError:
+            os.dup2(os.open(os.devnull, os.O_WRONLY), sys.stdout.fileno()) # handle broken pipe gracefully
+        except visidata.ExpectedException as e:
+            print(str(e))
+        except Exception as e:
+            rc = 1
+            vd.exceptionCaught(e)
+            if flDebug:
+                raise
+
+        sys.stderr.flush()
+        sys.stdout.flush()
+        os._exit(rc)  # cleanup can be expensive
+
+    import subprocess
+    return subprocess.run(['git', *args]).returncode

visidata/apps/vgit/remote.py

@@ -0,0 +1,57 @@
+from visidata import vd, VisiData, ItemColumn, AttrDict, RowColorizer, Path
+
+from .gitsheet import GitSheet
+
+@VisiData.api
+def git_remote(vd, p, args):
+    if not args or 'show' in args:
+        return GitRemotes('remotes', source=p)
+
+
+class GitRemotes(GitSheet):
+    guide = '''
+        # git remote
+        Manage the set of repositories ("remotes") whose branches you track.
+
+        - `a` to add a remote
+        - `d` to mark a remote for deletion
+        - `e` to edit the _remote_ or _url_
+        - `z Ctrl+S` to commit the changes.
+    '''
+    rowtypes = 'remotes'  # rowdef: dict(remote=, url=, type=)
+    columns=[
+        ItemColumn('remote', setter=lambda c,r,v: c.sheet.set_remote(c,r,v)),
+        ItemColumn('type'),
+        ItemColumn('url', width=40, setter=lambda c,r,v: c.sheet.set_url(c,r,v)),
+    ]
+    nKeys = 1
+    defer = True
+
+    def set_remote(self, col, row, val):
+        self.loggit('remote', 'rename', self.column('remote').getSourceValue(row), val)
+
+    def set_url(self, col, row, val):
+        self.loggit('remote', 'set-url', row.remote, val)
+
+    def iterload(self):
+        for line in self.git_lines('remote', '-v', 'show'):
+            name, url, paren_type = line.split()
+            yield AttrDict(remote=name, url=url, type=paren_type[1:-1])
+
+    def commitDeleteRow(self, row):
+        self.loggit('remote', 'remove', row.remote)
+
+    def commitAddRow(self, row):
+        row.remote = self.column('remote').getValue(row)
+        row.url = self.column('url').getValue(row)
+        self.loggit('remote', 'add', row.remote, row.url)
+
+    def newRow(self):
+        return AttrDict()
+
+
+GitSheet.addCommand('', 'git-open-remotes', 'vd.push(git_remote(Path("."), ""))', 'open git remotes sheet')
+
+vd.addMenuItems('''
+    Git > Open > remotes > git-open-remotes
+''')

visidata/apps/vgit/repos.py

@@ -0,0 +1,71 @@
+from visidata import vd, VisiData, Sheet, Column, AttrColumn, date, vlen, asyncthread, Path, namedlist, PyobjSheet, modtime, AttrDict
+
+from .gitsheet import GitSheet
+
+@VisiData.api
+def guess_git(vd, p):
+    if (p/'.git').is_dir():
+        return dict(filetype='git', _likelihood=10)
+
+
+@VisiData.api
+def open_git(vd, p):
+    return vd.git_status(p, [])
+
+
+@VisiData.api
+def git_repos(vd, p, args):
+    return GitRepos(p.base_stem, source=p)
+
+
+class GitLinesColumn(Column):
+    def __init__(self, name, cmd, *args, **kwargs):
+        super().__init__(name, cache='async', **kwargs)
+        cmdparts = cmd.split()
+        if cmdparts[0] == 'git':
+            cmdparts = cmdparts[1:]
+        self.gitargs = cmdparts + list(args)
+
+    def calcValue(self, r):
+        lines = list(GitSheet(source=r).git_lines(*self.gitargs))
+        if lines:
+            return lines
+
+
+class GitAllColumn(GitLinesColumn):
+    def calcValue(self, r):
+        return GitSheet(source=r).git_all(*self.gitargs).strip()
+
+
+
+class GitRepos(GitSheet):
+    guide = '''
+        # git repos
+        A list of git repositories under `{sheet.source}`
+
+        - `Enter` to open the status sheet for the current repo
+    '''
+    rowtype = 'git repos'  # rowdef: Path
+    columns = [
+        Column('repo', type=str, width=30),
+        GitAllColumn('branch', 'git rev-parse --abbrev-ref HEAD', width=8),
+        GitLinesColumn('diffs', 'git diff --no-color', type=vlen, width=8),
+        GitLinesColumn('staged_diffs', 'git diff --cached', type=vlen, width=8),
+        GitLinesColumn('branches', 'git branch --no-color', type=vlen, width=10),
+        GitLinesColumn('stashes', 'git stash list', type=vlen, width=8),
+        Column('modtime', type=date, getter=lambda c,r: modtime(r)),
+    ]
+    nKeys = 1
+
+    def iterload(self):
+        import glob
+        for fn in glob.glob('**/.git', root_dir=self.source, recursive=True):
+            yield Path(fn).parent
+
+
+    def openRow(self, row):
+        return vd.git_status(row, [])
+
+    def openCell(self, col, row):
+        val = col.getValue(row)
+        return PyobjSheet(getattr(val, '__name__', ''), source=val)

visidata/apps/vgit/setup.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+
+from setuptools import setup, find_packages
+
+# Note: use `python3 visidata/apps/setup.py install` from the root directory
+
+__version__ = '0.2-dev'
+
+setup(name='vgit',
+      version=__version__,
+      description='a sleek terminal user interface for git',
+      # long_description=open('README.md').read(),
+      install_requires=['sh<2'], # visidata
+      packages=find_packages(exclude=["tests"]),
+      scripts=['vgit'],
+      entry_points={'visidata.plugins': 'vgit=visidata.apps.vgit'},
+      author='Saul Pwanson',
+      author_email='vgit@saul.pw',
+      url='https://github.com/saulpw/visidata/vgit',
+      license='GPLv3',
+      python_requires='>=3.7',
+      classifiers=[
+          'Development Status :: 2 - Pre-Alpha',
+          'Environment :: Console',
+          'Environment :: Console :: Curses',
+          'Intended Audience :: Developers',
+          'Intended Audience :: System Administrators',
+          'Intended Audience :: Information Technology',
+          'License :: OSI Approved :: GNU General Public License v3 (GPLv3)',
+          'Operating System :: OS Independent',
+          'Programming Language :: Python :: 3',
+          'Topic :: Utilities',
+          'Topic :: Software Development :: Version Control',
+          'Topic :: Terminals'
+      ],
+      keywords=('console textpunk git version-control curses visidata tui terminal'),
+      )