pygments-shell-console 0.9.0__py3-none-any.whl

pygments_shell_console/__init__.py

@@ -0,0 +1,5 @@
+"""Pygments plugin: shell console sessions with highlighted prompts and git output."""
+
+from .git import *  # noqa: F401,F403
+from .shell import ShellConsoleLexer  # noqa: F401
+from .style import ShellConsoleStyle  # noqa: F401

pygments_shell_console/git.py

@@ -0,0 +1,291 @@
+"""Lexers for the output of git commands."""
+
+import re
+
+from pygments.lexer import Lexer, RegexLexer, bygroups, default, line_re, \
+    using
+from pygments.lexers.diff import DiffLexer
+from pygments.token import STANDARD_TYPES, Comment, Generic, Token, Whitespace
+
+__all__ = [
+    'GitLexer',
+    'GitStatusLexer',
+    'GitShortStatusLexer',
+    'GitLogLexer',
+    'GitPrettyLogLexer',
+    'GitShowLexer',
+    'GitBranchLexer',
+    'GitMergeLexer',
+]
+
+STANDARD_TYPES.update({
+    Token.Git: 'git',
+    Token.Git.BranchLine: 'git-bl',
+    Token.Git.CommitHash: 'git-ch',
+    Token.Git.CommitDate: 'git-cd',
+    Token.Git.CommitMessage: 'git-cm',
+    Token.Git.CommitAuthor: 'git-ca',
+    Token.Git.Hint: 'git-hint',
+    Token.Git.Warning: 'git-warning',
+    Token.Git.Error: 'git-error',
+    Token.Git.Fatal: 'git-fatal',
+    Token.Git.Refs: 'git-r',
+    Token.Git.Untracked: 'git-untr',
+    Token.Git.Modified: 'git-mod',
+    Token.Git.Unmerged: 'git-unm',
+    Token.Git.Staged: 'git-stg',
+    Token.Git.Show: 'git-show',
+    Token.Git.Show.Header: 'git-show-h',
+    Token.Git.Refs.RemoteHead: 'git-rh',
+    Token.Git.Refs.Head: 'git-h',
+    Token.Git.Refs.Tag: 'git-t',
+    Token.Git.Refs.RemoteBranch: 'git-rb',
+    Token.Git.Refs.Branch: 'git-b',
+})
+
+# Remote names recognised in ref decorations, e.g. "origin/main".
+_REMOTES = r'(?:origin|upstream)'
+
+
+class GitLexer(RegexLexer):
+    """Generic git output: highlights error, fatal, hint and warning lines."""
+
+    name = 'Git'
+    aliases = ['git']
+    filenames = ['*.git']
+    version_added = '1.0'
+
+    tokens = {
+        'root': [
+            (r'\n', Whitespace),
+            (r'^error:.*\n', Token.Git.Error),
+            (r'^fatal:.*\n', Token.Git.Fatal),
+            (r'^hint:.*\n', Token.Git.Hint),
+            (r'^warning:.*\n', Token.Git.Warning),
+            (r'^.*\n', Generic.Output),
+            (r'[^\n]+', Generic.Output),
+        ],
+    }
+
+
+def _status_section(token):
+    """Rules for a `git status` file list, colouring each entry with `token`."""
+    return [
+        (r'^\s*\n', Whitespace, '#pop'),
+        (r'^\s+\(.*\)\n', Generic.Output),
+        (r'^(\s*)([^\n]+)(\n)', bygroups(Whitespace, token, Whitespace)),
+    ]
+
+
+class GitStatusLexer(RegexLexer):
+    """Output of `git status`."""
+
+    name = 'Git Status'
+    aliases = ['git-status']
+    version_added = '1.0'
+
+    tokens = {
+        'root': [
+            (r'^\n', Whitespace),
+            (r'\s*Untracked files:\n', Generic.Output, 'untracked'),
+            (r'\s*Changes not staged for commit:\n', Generic.Output, 'modified'),
+            (r'\s*Changes to be committed:\n', Generic.Output, 'staged'),
+            (r'\s*Unmerged paths:\n', Generic.Output, 'unmerged'),
+            (r'^.*\n', using(GitLexer)),
+        ],
+        'untracked': _status_section(Token.Git.Untracked),
+        'modified': _status_section(Token.Git.Modified),
+        'staged': _status_section(Token.Git.Staged),
+        'unmerged': _status_section(Token.Git.Unmerged),
+    }
+
+
+class GitShortStatusLexer(RegexLexer):
+    """Output of `git status --short` / `--porcelain`."""
+
+    name = 'Git Short Status'
+    aliases = ['git-short-status']
+    version_added = '1.0'
+
+    tokens = {
+        'root': [
+            (r'^\n', Whitespace),
+            (r'^(## )(No commits yet on )(\S+)(.*\n)', bygroups(
+                Generic.Output, Generic.Output,
+                Token.Git.Refs.Branch, Generic.Output,
+            )),
+            (r'^(## )(\S+?)(?:(\.\.\.)(\S+))?(\s.*\n|\n)', bygroups(
+                Generic.Output, Token.Git.Refs.Branch,
+                Generic.Output, Token.Git.Refs.RemoteBranch, Generic.Output,
+            )),
+            (r'^(\?\?)( )(.*)(\n)', bygroups(
+                Token.Git.Untracked, Whitespace, Generic.Output, Whitespace,
+            )),
+            (r'^(DD|AU|UD|UA|DU|AA|UU)( )(.*)(\n)', bygroups(
+                Token.Git.Unmerged, Whitespace, Generic.Output, Whitespace,
+            )),
+            (r'^([MTADRC ])([MTADRC ])( )(.*)(\n)', bygroups(
+                Token.Git.Staged, Token.Git.Modified,
+                Whitespace, Generic.Output, Whitespace,
+            )),
+            (r'^.*\n', using(GitLexer)),
+        ],
+    }
+
+
+class GitLogLexer(RegexLexer):
+    """Output of `git log`, including `--oneline` and `-p`."""
+
+    name = 'Git Log'
+    aliases = ['git-log']
+    version_added = '1.0'
+
+    tokens = {
+        'root': [
+            (r'^\n', Whitespace),
+            (r'^commit [0-9a-f]+', Token.Git.Show.Header, 'header'),
+            (r'^[0-9a-f]{7,40}(?= )', Token.Git.CommitHash, 'oneline'),
+            (r'^diff .*\n', using(DiffLexer), 'diff'),
+            (r'^.*\n', using(GitLexer)),
+        ],
+        'header': [
+            (r' +', Whitespace),
+            (r'\(', Token.Git.Show.Header, 'refs'),
+            (r'\n', Whitespace, '#pop'),
+        ],
+        'oneline': [
+            (r'( )(\()', bygroups(Whitespace, Token.Git.Show.Header), 'refs'),
+            (r'( )(.*)(\n)', bygroups(
+                Whitespace, Token.Git.CommitMessage, Whitespace,
+            ), '#pop'),
+            (r'\n', Whitespace, '#pop'),
+        ],
+        'refs': [
+            (r' +', Whitespace),
+            (r'->|,', Token.Git.Show.Header),
+            (r'\)', Token.Git.Show.Header, '#pop'),
+            (_REMOTES + r'/HEAD\b', Token.Git.Refs.RemoteHead),
+            (r'HEAD\b', Token.Git.Refs.Head),
+            (r'tag: [^\s,()]+', Token.Git.Refs.Tag),
+            (_REMOTES + r'/[^\s,()]+', Token.Git.Refs.RemoteBranch),
+            (r'[^\s,()]+', Token.Git.Refs.Branch),
+        ],
+        # Patch output (`git show`, `git log -p`) lasts until the next commit.
+        'diff': [
+            (r'^(?!commit [0-9a-f]+).*\n', using(DiffLexer)),
+            default('#pop'),
+        ],
+    }
+
+
+class GitShowLexer(GitLogLexer):
+    """Output of `git show`. Same format as `git log -p`."""
+
+    name = 'Git Show'
+    aliases = ['git-show']
+
+
+class GitPrettyLogLexer(Lexer):
+    """Output of `git log --graph` using the format described in the README."""
+
+    name = 'Git Pretty Log'
+    aliases = ['git-pretty-log']
+    version_added = '1.0'
+
+    _branch_line = r'([\|\\\/ _]*)'
+    _letters = r'0-9A-Za-zÀ-ÖØ-öø-ÿ'
+    _log_re = re.compile(''.join([
+        _branch_line,                           # 1. Branch line
+        r'(\*)',                                # 2. Commit asterisk
+        _branch_line,                           # 3. Branch line
+        r'( +)',                                # 4. Space
+        r'([a-f0-9]+)',                         # 5. Commit hash
+        r'( +)',                                # 6. Space
+        r'(-)',                                 # 7. Commit separator
+        r'( +)',                                # 8. Space
+        rf'(\([{_letters} ]+\))',               # 9. Date
+        r'(\s+)',                               # 10. Space
+        r'([^\n]+)',                            # 11. Commit message
+        r'( +)',                                # 12. Space
+        r'(-)',                                 # 13. Commit separator
+        r'( +)',                                # 14. Space
+        rf'([{_letters} ]*[{_letters}]+)',      # 15. Author
+        r'( *)',                                # 16. Space
+        r'(\([\w ->,:/.]+\))?',                 # 17. Refs
+        r'( *)',                                # 18. Space
+        r'(#[^\n]*)?',                          # 19. Comment
+        r'\n',
+    ]))
+    _branch_line_re = re.compile(_branch_line + r'\n?$')
+
+    _log_tokens = {
+        1: Token.Git.BranchLine,
+        3: Token.Git.BranchLine,
+        4: Whitespace,
+        5: Token.Git.CommitHash,
+        6: Whitespace,
+        8: Whitespace,
+        9: Token.Git.CommitDate,
+        10: Whitespace,
+        11: Token.Git.CommitMessage,
+        12: Whitespace,
+        14: Whitespace,
+        15: Token.Git.CommitAuthor,
+        16: Whitespace,
+        17: Token.Git.Refs,
+        18: Whitespace,
+        19: Comment,
+    }
+
+    def get_tokens_unprocessed(self, text):
+        for match in line_re.finditer(text):
+            line = match.group()
+            start = match.start()
+
+            match_log = self._log_re.match(line)
+            if match_log:
+                for i in range(1, self._log_re.groups + 1):
+                    if match_log.group(i):
+                        token = self._log_tokens.get(i, Generic.Output)
+                        yield start + match_log.start(i), token, match_log.group(i)
+                yield start + match_log.end() - 1, Whitespace, '\n'
+            elif self._branch_line_re.match(line):
+                yield start, Token.Git.BranchLine, line
+            else:
+                yield start, Generic.Output, line
+
+
+class GitBranchLexer(RegexLexer):
+    """Output of `git branch`: highlights the current branch."""
+
+    name = 'Git Branch'
+    aliases = ['git-branch']
+    version_added = '1.0'
+
+    tokens = {
+        'root': [
+            (r'^\n', Whitespace),
+            (r'^(\* )(.*?)(\n)', bygroups(
+                using(GitLexer), Token.Git.Refs.Branch, Whitespace,
+            )),
+            (r'^.*\n', using(GitLexer)),
+        ],
+    }
+
+
+class GitMergeLexer(RegexLexer):
+    """Diffstat output, as printed by `git merge`, `git pull`, `--stat`..."""
+
+    name = 'Git Merge'
+    aliases = ['git-merge', 'git-stat']
+    version_added = '1.0'
+
+    tokens = {
+        'root': [
+            (r'^\n', Whitespace),
+            (r'^( \S+ +\| +\d+ )(\+*)(\-*)(\n)', bygroups(
+                Generic.Output, Generic.Inserted, Generic.Deleted, Whitespace,
+            )),
+            (r'^.*\n', using(GitLexer)),
+        ],
+    }

pygments_shell_console/shell.py

@@ -0,0 +1,213 @@
+"""Lexer for interactive shell sessions with highlighted prompts and output."""
+
+import re
+
+from pygments.lexer import Lexer, do_insertions, line_re
+from pygments.lexers.diff import DiffLexer
+from pygments.lexers.shell import BashLexer
+from pygments.token import STANDARD_TYPES, Generic, Token
+
+from .git import GitBranchLexer, GitLexer, GitLogLexer, GitMergeLexer, \
+    GitPrettyLogLexer, GitShortStatusLexer, GitShowLexer, GitStatusLexer
+
+__all__ = ['ShellConsoleLexer']
+
+STANDARD_TYPES.update({
+    Token.Generic.Prompt.Whitespace: 'gp-w',
+    Token.Generic.Prompt.UserHost: 'gp-uh',
+    Token.Generic.Prompt.Directory: 'gp-d',
+    Token.Generic.Prompt.GitBranch: 'gp-gb',
+    Token.Generic.Prompt.VirtualEnv: 'gp-ve',
+})
+
+# Git global options that take a separate value, e.g. `git -C repo status`.
+_GIT_OPTIONS_WITH_VALUE = {'-C', '-c', '--git-dir', '--work-tree', '--namespace'}
+
+# Unterminated here-document, e.g. `cat <<EOF` (but not `<<<` here-strings).
+_HEREDOC_RE = re.compile(r"(?<!<)<<(?!<)-?\s*(['\"]?)([A-Za-z_]\w*)\1")
+
+# Line ending in a pipe or a list operator, so bash keeps reading.
+_TRAILING_OPERATOR_RE = re.compile(r'(?:\|\|?|&&)\s*\n\Z')
+
+
+def _git_args(words):
+    """Return the arguments after `git` and its global options."""
+    args = words[1:]
+    while args and args[0].startswith('-'):
+        option = args.pop(0)
+        if option in _GIT_OPTIONS_WITH_VALUE and args:
+            args.pop(0)
+    return args
+
+
+def _output_lexer_class(command):
+    """Choose the lexer for the output of `command`, or None for plain output."""
+    words = command.split()
+    if words and words[0] == 'sudo':
+        words = words[1:]
+    if not words:
+        return None
+
+    if words[0] in ('diff', 'colordiff'):
+        return DiffLexer
+    if words[0] == 'cat' and any(w.endswith(('.diff', '.patch')) for w in words):
+        return DiffLexer
+    if words[0] != 'git':
+        return None
+
+    args = _git_args(words)
+    if not args:
+        return GitLexer
+    subcommand, options = args[0], args[1:]
+
+    if subcommand == 'diff':
+        return GitMergeLexer if '--stat' in options else DiffLexer
+    if subcommand == 'show':
+        return GitShowLexer
+    if subcommand.startswith('lg') or (subcommand == 'log' and '--graph' in options):
+        return GitPrettyLogLexer
+    if subcommand == 'log':
+        return GitLogLexer
+    if subcommand == 'status':
+        short = any(o in ('--short', '--porcelain') or re.fullmatch(r'-[a-z]*s[a-z]*', o)
+                    for o in options)
+        return GitShortStatusLexer if short else GitStatusLexer
+    if subcommand == 'stash' and options:
+        if options[0] in ('apply', 'pop'):
+            return GitStatusLexer
+        if options[0] == 'show':
+            return DiffLexer if {'-p', '--patch'} & set(options) else GitMergeLexer
+    if subcommand == 'branch':
+        return GitBranchLexer
+    if subcommand in ('merge', 'pull'):
+        return GitMergeLexer
+    return GitLexer
+
+
+def _continues(code):
+    """Whether bash would print PS2 and keep reading after `code`."""
+    if code.endswith('\\\n') or _TRAILING_OPERATOR_RE.search(code):
+        return True
+
+    pending = []
+    for line in code.splitlines():
+        if pending:
+            if line.strip() == pending[0]:
+                pending.pop(0)
+        else:
+            pending.extend(m.group(2) for m in _HEREDOC_RE.finditer(line))
+    return bool(pending)
+
+
+class ShellConsoleLexer(Lexer):
+    """
+    Shell session where prompts are split into their parts (virtualenv,
+    user@host, directory, git branch) and the output of known commands
+    (diff, git) is highlighted.
+    """
+
+    name = 'Shell Console'
+    aliases = ['shellconsole', 'shell-console']
+    filenames = ['*.sh-session', '*.shell-session']
+    mimetypes = ['application/x-shell-session', 'application/x-sh-session']
+    url = 'https://en.wikipedia.org/wiki/Unix_shell'
+    version_added = '1.0'
+
+    _ps1_re = re.compile(r'''
+        (?P<venv>\([^)]*\))?
+        (?P<ws1>\s*)
+        (?P<open>\[)?
+        (?:
+            (?P<user_host>[^\n$%\#]+@[^\s$%\#]+?)
+            (?:(?P<ws2>\s*)(?P<colon>:)(?P<ws3>\s*)|(?P<ws4>\s+))
+            (?P<current_dir>[^\s\]:$%\#]+)
+        )?
+        (?:(?P<ws5>\s+)(?P<git_branch>\([^)]+\)))?
+        (?P<close>\])?
+        (?P<ws6>\s*)
+        # `#` (root) is only accepted after user@host, so comments aren't prompts.
+        (?P<sigil>(?:[$%]|(?(user_host)\#|(?!)))\n?)
+        (?P<ws7>\s*)
+        (?P<command>.*\n?)
+    ''', re.VERBOSE)
+
+    _ps1_tokens = {
+        'venv': Generic.Prompt.VirtualEnv,
+        'user_host': Generic.Prompt.UserHost,
+        'current_dir': Generic.Prompt.Directory,
+        'git_branch': Generic.Prompt.GitBranch,
+        'open': Generic.Prompt,
+        'close': Generic.Prompt,
+        'colon': Generic.Prompt,
+        'sigil': Generic.Prompt,
+    }
+
+    _ps2 = '> '
+
+    def get_tokens_unprocessed(self, text):
+        innerlexer = BashLexer(**self.options)
+        output_lexers = {}
+
+        # Command being collected: start position, code and prompt insertions.
+        command_pos = 0
+        curcode = ''
+        insertions = []
+        # Output of the last command: start position, text and lexer class.
+        output_pos = 0
+        output = ''
+        output_lexer_cls = None
+
+        def flush_command():
+            for i, t, v in do_insertions(
+                    insertions, innerlexer.get_tokens_unprocessed(curcode)):
+                yield command_pos + i, t, v
+
+        def flush_output():
+            if output_lexer_cls is None:
+                yield output_pos, Generic.Output, output
+                return
+            if output_lexer_cls not in output_lexers:
+                output_lexers[output_lexer_cls] = output_lexer_cls()
+            lexer = output_lexers[output_lexer_cls]
+            for i, t, v in lexer.get_tokens_unprocessed(output):
+                yield output_pos + i, t, v
+
+        for match in line_re.finditer(text):
+            line = match.group()
+
+            # Continuation of a multi-line command (backslash, heredoc...)
+            if insertions and _continues(curcode):
+                if line.startswith(self._ps2):
+                    insertions.append((len(curcode),
+                                       [(0, Generic.Prompt, self._ps2)]))
+                    line = line[len(self._ps2):]
+                curcode += line
+
+            elif m := self._ps1_re.match(line):
+                if output:
+                    yield from flush_output()
+                    output = ''
+
+                command_pos = match.start()
+                curcode = m.group('command')
+                prompt = [
+                    (0, self._ps1_tokens.get(name, Generic.Prompt.Whitespace), value)
+                    for name, value in m.groupdict().items()
+                    if value and name != 'command'
+                ]
+                insertions = [(0, prompt)]
+
+            else:
+                if not output:
+                    output_pos = match.start()
+                    output_lexer_cls = _output_lexer_class(curcode)
+                output += line
+
+            if insertions and not _continues(curcode):
+                yield from flush_command()
+                insertions = []
+
+        if insertions:
+            yield from flush_command()
+        if output:
+            yield from flush_output()

pygments_shell_console/style.py

@@ -0,0 +1,38 @@
+"""Pygments style for the shell console and git tokens."""
+
+from pygments.style import Style
+from pygments.styles.default import DefaultStyle
+from pygments.token import Generic, Token
+
+
+class ShellConsoleStyle(Style):
+    styles = DefaultStyle.styles.copy()
+    styles.update({
+        Generic.Prompt.UserHost: "#008000",
+        Generic.Prompt.Directory: "#19177C",
+        Generic.Prompt.GitBranch: "#767600",
+        Generic.Prompt.VirtualEnv: "#800000",
+
+        Token.Git.BranchLine: "#f00",
+        Token.Git.CommitHash: "#00f",
+        Token.Git.CommitDate: "#008000",
+        Token.Git.CommitAuthor: "#aaaaaa",
+        Token.Git.Hint: "#aaaa00",
+        Token.Git.Warning: "#aaaa00",
+        Token.Git.Error: "#f00",
+        Token.Git.Fatal: "bold #f00",
+        Token.Git.Show.Header: "#aaaa00",
+
+        Token.Git.Refs: "#00ffff",
+        Token.Git.Refs.Tag: "#ffff00",
+        Token.Git.Refs.Head: "#00ffff",
+        Token.Git.Refs.Branch: "#00ff00",
+        Token.Git.Refs.RemoteHead: "#ffcc00",
+        Token.Git.Refs.RemoteBranch: "#ffcc00",
+
+        Token.Git.Untracked: "#f00",
+        Token.Git.Modified: "#f00",
+        Token.Git.Unmerged: "#f00",
+        Token.Git.Staged: "#008000",
+    })
+    del styles[Token.Generic.Prompt]

pygments_shell_console-0.9.0.dist-info/METADATA

@@ -0,0 +1,87 @@
+Metadata-Version: 2.5
+Name: pygments-shell-console
+Version: 0.9.0
+Summary: Pygments lexers for shell console sessions, with highlighted prompts and git output
+Project-URL: Homepage, https://github.com/joapuiib/pygments-shell-console
+Requires-Python: >=3.8
+Requires-Dist: pygments
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Pygments Shell Console
+[![Python](https://img.shields.io/badge/python-3670A0?style=for-the-badge&logo=python&logoColor=ffdd54)](https://www.python.org/)
+[![PyPI](https://img.shields.io/badge/pypi-3775A9?style=for-the-badge&logo=pypi&logoColor=white)](https://pypi.org/project/pygments-shell-console/)
+
+Pygments lexers for shell console sessions: highlighted prompts and git output.
+
+![Example](https://raw.githubusercontent.com/joapuiib/pygments-shell-console/main/docs/example.png)
+
+## Install
+
+```
+pip install pygments-shell-console
+```
+
+## Usage
+
+Use the `shellconsole` lexer with the `shellconsole-style` style:
+
+```
+pygmentize -l shellconsole -O style=shellconsole-style session.txt
+```
+
+In Markdown (MkDocs, Sphinx...), use `shellconsole` as the code block language:
+
+````
+```shellconsole
+user@host:~/project (main) $ git status
+```
+````
+
+## Prompt
+
+The prompt elements are highlighted separately:
+
+```
+(venv) user@host:~/project (main) $
+```
+
+Virtualenv, `user@host`, directory and git branch. Also supported:
+
+- Root prompts (`root@host:~#`) and `[user@host ~]` style prompts.
+- Continuation lines: backslash, trailing `|`, `&&` or `||`, and here-documents.
+
+## Output
+
+The output lexer is chosen from the command. `sudo` and git global options
+(`-C dir`, `--no-pager`...) are skipped.
+
+| Command | Lexer | Alias |
+|---|---|---|
+| `diff`, `git diff`, `git stash show -p` | `DiffLexer` | |
+| `git status` | `GitStatusLexer` | `git-status` |
+| `git status -s`, `--porcelain` | `GitShortStatusLexer` | `git-short-status` |
+| `git show` | `GitShowLexer` | `git-show` |
+| `git log`, `--oneline`, `-p` | `GitLogLexer` | `git-log` |
+| `git lg*`, `git log --graph` | `GitPrettyLogLexer` | `git-pretty-log` |
+| `git branch` | `GitBranchLexer` | `git-branch` |
+| `git merge`, `pull`, `stash show`, `diff --stat` | `GitMergeLexer` | `git-merge` |
+| any other `git` command | `GitLexer` | `git` |
+
+The git lexers can also be used on their own through their alias.
+
+`git lg*` expects this format:
+
+```
+log --graph --abbrev-commit --decorate --format=format:'%C(bold blue)%h%C(reset) - %C(bold green)(%ar)%C(reset) %C(white)%s%C(reset) %C(dim white)- %an%C(reset)%C(bold yellow)%d%C(reset)'
+```
+
+More examples: [mkdocs-material-joapuiib](https://joapuiib.github.io/mkdocs-material-joapuiib/features/blocs_de_codi/#bloc-de-consola).
+
+## Development
+
+```
+pip install -e '.[test]'
+pytest
+```

pygments_shell_console-0.9.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+pygments_shell_console/__init__.py,sha256=8Z_8TLhJoEHyDGEF47CLP64A-Cmwq0LSZ9-CwbD_goE,228
+pygments_shell_console/git.py,sha256=6OQqV4L_Y4IzvW1l0StXVu3zjiM79ZxW0jd_MZpqIxc,9619
+pygments_shell_console/shell.py,sha256=Cs8kKo6ssTXKSEz0QI-tOnv9N1amAk0Uqzq4JHqW-uU,7341
+pygments_shell_console/style.py,sha256=ZIU2dzyHEUTCUiN-ayHb4qsFe5QSRfH0NVev4NWRJ-w,1247
+pygments_shell_console-0.9.0.dist-info/METADATA,sha256=TjvkDHtQ4k5R_xKsQtP7njSN_jIrew-1YCLpIM5_Je8,2766
+pygments_shell_console-0.9.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+pygments_shell_console-0.9.0.dist-info/entry_points.txt,sha256=buFWIELViJ-euWM8pJwmN9B_aXom1f4DcFz6v_E_918,600
+pygments_shell_console-0.9.0.dist-info/RECORD,,

pygments_shell_console-0.9.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

pygments_shell_console-0.9.0.dist-info/entry_points.txt

@@ -0,0 +1,13 @@
+[pygments.lexers]
+git = pygments_shell_console.git:GitLexer
+git-branch = pygments_shell_console.git:GitBranchLexer
+git-log = pygments_shell_console.git:GitLogLexer
+git-merge = pygments_shell_console.git:GitMergeLexer
+git-pretty-log = pygments_shell_console.git:GitPrettyLogLexer
+git-short-status = pygments_shell_console.git:GitShortStatusLexer
+git-show = pygments_shell_console.git:GitShowLexer
+git-status = pygments_shell_console.git:GitStatusLexer
+shellconsole = pygments_shell_console.shell:ShellConsoleLexer
+
+[pygments.styles]
+shellconsole-style = pygments_shell_console.style:ShellConsoleStyle