mycli 1.29.1__py3-none-any.whl

doc/key_bindings.rst

@@ -0,0 +1,65 @@
+*************
+Key Bindings:
+*************
+
+Most key bindings are simply inherited from `prompt-toolkit <https://python-prompt-toolkit.readthedocs.io/en/master/index.html>`_ .
+
+The following key bindings are special to mycli:
+
+###
+F2
+###
+
+Enable/Disable SmartCompletion Mode.
+
+###
+F3
+###
+
+Enable/Disable Multiline Mode.
+
+###
+F4
+###
+
+Toggle between Vi and Emacs mode.
+
+###
+Tab
+###
+
+Force autocompletion at cursor.
+
+#######
+C-space
+#######
+
+Initialize autocompletion at cursor.
+
+If the autocompletion menu is not showing, display it with the appropriate completions for the context.
+
+If the menu is showing, select the next completion.
+
+#########
+ESC Enter
+#########
+
+Introduce a line break in multi-line mode, or dispatch the command in single-line mode.
+
+The sequence ESC-Enter is often sent by Alt-Enter.
+
+##################
+C-x p (Emacs-mode)
+##################
+
+Prettify and indent current statement, usually into multiple lines.
+
+Only accepts buffers containing single SQL statements.
+
+##################
+C-x u (Emacs-mode)
+##################
+
+Unprettify and dedent current statement, usually into one line.
+
+Only accepts buffers containing single SQL statements.

mycli/AUTHORS

@@ -0,0 +1,107 @@
+Core Developers:
+----------------
+
+  * Thomas Roten
+  * Irina Truong
+  * Matheus Rosa
+  * Darik Gamble
+  * Dick Marinus
+  * Amjith Ramanujam
+
+Contributors:
+-------------
+
+  * 0xflotus
+  * Abirami P
+  * Adam Chainz
+  * Aljosha Papsch
+  * Andy Teijelo Pérez
+  * Angelo Lupo
+  * Artem Bezsmertnyi
+  * bitkeen
+  * bjarnagin
+  * BuonOmo
+  * caitinggui
+  * Carlos Afonso
+  * Casper Langemeijer
+  * chainkite
+  * Claude Becker
+  * Colin Caine
+  * cxbig
+  * Daniel Black
+  * Daniel West
+  * Daniël van Eeden
+  * Fabrizio Gennari
+  * François Pietka
+  * Frederic Aoustin
+  * Georgy Frolov
+  * Heath Naylor
+  * Huachao Mao
+  * Ishaan Bhimwal
+  * Jakub Boukal
+  * jbruno
+  * Jerome Provensal
+  * Jialong Liu
+  * Johannes Hoff
+  * John Sterling
+  * Jonathan Bruno
+  * Jonathan Lloyd
+  * Jonathan Slenders
+  * Kacper Kwapisz
+  * Karthikeyan Singaravelan
+  * kevinhwang91
+  * KITAGAWA Yasutaka
+  * Klaus Wünschel
+  * laixintao
+  * Lennart Weller
+  * Martijn Engler
+  * Massimiliano Torromeo
+  * Michał Górny
+  * Mike Palandra
+  * Mikhail Borisov
+  * Morgan Mitchell
+  * mrdeathless
+  * Nathan Huang
+  * Nicolas Palumbo
+  * Phil Cohen
+  * QiaoHou Peng
+  * Roland Walker
+  * Ryan Smith
+  * Scrappy Soft
+  * Seamile
+  * Shoma Suzuki
+  * spacewander
+  * Steve Robbins
+  * Takeshi D. Itoh
+  * Terje Røsten
+  * Terseus
+  * Tyler Kuipers
+  * ushuz
+  * William GARCIA
+  * xeron
+  * Yang Zou
+  * Yasuhiro Matsumoto
+  * Yuanchun Shang
+  * Zach DeCook
+  * Zane C. Bowers-Hadley
+  * zer09
+  * Zhaolong Zhu
+  * Zhidong
+  * Zhongyang Guan
+  * Arvind Mishra
+  * Kevin Schmeichel
+  * Mel Dafert
+  * Thomas Copper
+  * Will Wang
+  * Alfred Wingate
+  * Zhanze Wang
+  * Houston Wong
+  * Mohamed Rezk
+  * Ryosuke Kazami
+  * Cornel Cruceru
+
+
+Created by:
+-----------
+
+Amjith Ramanujam

mycli/SPONSORS

@@ -0,0 +1,31 @@
+Many thanks to the following Kickstarter backers.
+
+* Tech Blue Software
+* jweiland.net
+
+# Silver Sponsors
+
+* Whitane Tech
+* Open Query Pty Ltd
+* Prathap Ramamurthy
+* Lincoln Loop
+
+# Sponsors
+
+* Nathan Taggart
+* Iryna Cherniavska
+* Sudaraka Wijesinghe
+* www.mysqlfanboy.com
+* Steve Robbins
+* Norbert Spichtig
+* orpharion bestheneme
+* Daniel Black
+* Anonymous
+* Magnus udd
+* Anonymous
+* Lewis Peckover
+* Cyrille Tabary
+* Heath Naylor
+* Ted Pennings
+* Chris Anderton
+* Jonathan Slenders

mycli/__init__.py

@@ -0,0 +1,3 @@
+import importlib.metadata
+
+__version__ = importlib.metadata.version("mycli")

mycli/clibuffer.py

@@ -0,0 +1,55 @@
+from prompt_toolkit.enums import DEFAULT_BUFFER
+from prompt_toolkit.filters import Condition
+from prompt_toolkit.application import get_app
+from .packages import special
+
+
+def cli_is_multiline(mycli):
+    @Condition
+    def cond():
+        doc = get_app().layout.get_buffer_by_name(DEFAULT_BUFFER).document
+
+        if not mycli.multi_line:
+            return False
+        else:
+            return not _multiline_exception(doc.text)
+
+    return cond
+
+
+def _multiline_exception(text):
+    orig = text
+    text = text.strip()
+
+    # Multi-statement favorite query is a special case. Because there will
+    # be a semicolon separating statements, we can't consider semicolon an
+    # EOL. Let's consider an empty line an EOL instead.
+    if text.startswith("\\fs"):
+        return orig.endswith("\n")
+
+    return (
+        # Special Command
+        text.startswith("\\")
+        or
+        # Delimiter declaration
+        text.lower().startswith("delimiter")
+        or
+        # Ended with the current delimiter (usually a semi-column)
+        text.endswith(special.get_current_delimiter())
+        or text.endswith("\\g")
+        or text.endswith("\\G")
+        or text.endswith(r"\e")
+        or text.endswith(r"\clip")
+        or
+        # Exit doesn't need semi-column`
+        (text == "exit")
+        or
+        # Quit doesn't need semi-column
+        (text == "quit")
+        or
+        # To all teh vim fans out there
+        (text == ":q")
+        or
+        # just a plain enter without any text
+        (text == "")
+    )

mycli/clistyle.py

@@ -0,0 +1,145 @@
+import logging
+
+import pygments.styles
+from pygments.token import string_to_tokentype, Token
+from pygments.style import Style as PygmentsStyle
+from pygments.util import ClassNotFound
+from prompt_toolkit.styles.pygments import style_from_pygments_cls
+from prompt_toolkit.styles import merge_styles, Style
+
+logger = logging.getLogger(__name__)
+
+# map Pygments tokens (ptk 1.0) to class names (ptk 2.0).
+TOKEN_TO_PROMPT_STYLE = {
+    Token.Menu.Completions.Completion.Current: "completion-menu.completion.current",
+    Token.Menu.Completions.Completion: "completion-menu.completion",
+    Token.Menu.Completions.Meta.Current: "completion-menu.meta.completion.current",
+    Token.Menu.Completions.Meta: "completion-menu.meta.completion",
+    Token.Menu.Completions.MultiColumnMeta: "completion-menu.multi-column-meta",
+    Token.Menu.Completions.ProgressButton: "scrollbar.arrow",  # best guess
+    Token.Menu.Completions.ProgressBar: "scrollbar",  # best guess
+    Token.SelectedText: "selected",
+    Token.SearchMatch: "search",
+    Token.SearchMatch.Current: "search.current",
+    Token.Toolbar: "bottom-toolbar",
+    Token.Toolbar.Off: "bottom-toolbar.off",
+    Token.Toolbar.On: "bottom-toolbar.on",
+    Token.Toolbar.Search: "search-toolbar",
+    Token.Toolbar.Search.Text: "search-toolbar.text",
+    Token.Toolbar.System: "system-toolbar",
+    Token.Toolbar.Arg: "arg-toolbar",
+    Token.Toolbar.Arg.Text: "arg-toolbar.text",
+    Token.Toolbar.Transaction.Valid: "bottom-toolbar.transaction.valid",
+    Token.Toolbar.Transaction.Failed: "bottom-toolbar.transaction.failed",
+    Token.Output.Header: "output.header",
+    Token.Output.OddRow: "output.odd-row",
+    Token.Output.EvenRow: "output.even-row",
+    Token.Output.Null: "output.null",
+    Token.Prompt: "prompt",
+    Token.Continuation: "continuation",
+}
+
+# reverse dict for cli_helpers, because they still expect Pygments tokens.
+PROMPT_STYLE_TO_TOKEN = {v: k for k, v in TOKEN_TO_PROMPT_STYLE.items()}
+
+# all tokens that the Pygments MySQL lexer can produce
+OVERRIDE_STYLE_TO_TOKEN = {
+    "sql.comment": Token.Comment,
+    "sql.comment.multi-line": Token.Comment.Multiline,
+    "sql.comment.single-line": Token.Comment.Single,
+    "sql.comment.optimizer-hint": Token.Comment.Special,
+    "sql.escape": Token.Error,
+    "sql.keyword": Token.Keyword,
+    "sql.datatype": Token.Keyword.Type,
+    "sql.literal": Token.Literal,
+    "sql.literal.date": Token.Literal.Date,
+    "sql.symbol": Token.Name,
+    "sql.quoted-schema-object": Token.Name.Quoted,
+    "sql.quoted-schema-object.escape": Token.Name.Quoted.Escape,
+    "sql.constant": Token.Name.Constant,
+    "sql.function": Token.Name.Function,
+    "sql.variable": Token.Name.Variable,
+    "sql.number": Token.Number,
+    "sql.number.binary": Token.Number.Bin,
+    "sql.number.float": Token.Number.Float,
+    "sql.number.hex": Token.Number.Hex,
+    "sql.number.integer": Token.Number.Integer,
+    "sql.operator": Token.Operator,
+    "sql.punctuation": Token.Punctuation,
+    "sql.string": Token.String,
+    "sql.string.double-quouted": Token.String.Double,
+    "sql.string.escape": Token.String.Escape,
+    "sql.string.single-quoted": Token.String.Single,
+    "sql.whitespace": Token.Text,
+}
+
+
+def parse_pygments_style(token_name, style_object, style_dict):
+    """Parse token type and style string.
+
+    :param token_name: str name of Pygments token. Example: "Token.String"
+    :param style_object: pygments.style.Style instance to use as base
+    :param style_dict: dict of token names and their styles, customized to this cli
+
+    """
+    token_type = string_to_tokentype(token_name)
+    try:
+        other_token_type = string_to_tokentype(style_dict[token_name])
+        return token_type, style_object.styles[other_token_type]
+    except AttributeError:
+        return token_type, style_dict[token_name]
+
+
+def style_factory(name, cli_style):
+    try:
+        style = pygments.styles.get_style_by_name(name)
+    except ClassNotFound:
+        style = pygments.styles.get_style_by_name("native")
+
+    prompt_styles = []
+    # prompt-toolkit used pygments tokens for styling before, switched to style
+    # names in 2.0. Convert old token types to new style names, for backwards compatibility.
+    for token in cli_style:
+        if token.startswith("Token."):
+            # treat as pygments token (1.0)
+            token_type, style_value = parse_pygments_style(token, style, cli_style)
+            if token_type in TOKEN_TO_PROMPT_STYLE:
+                prompt_style = TOKEN_TO_PROMPT_STYLE[token_type]
+                prompt_styles.append((prompt_style, style_value))
+            else:
+                # we don't want to support tokens anymore
+                logger.error("Unhandled style / class name: %s", token)
+        else:
+            # treat as prompt style name (2.0). See default style names here:
+            # https://github.com/jonathanslenders/python-prompt-toolkit/blob/master/prompt_toolkit/styles/defaults.py
+            prompt_styles.append((token, cli_style[token]))
+
+    override_style = Style([("bottom-toolbar", "noreverse")])
+    return merge_styles([style_from_pygments_cls(style), override_style, Style(prompt_styles)])
+
+
+def style_factory_output(name, cli_style):
+    try:
+        style = pygments.styles.get_style_by_name(name).styles
+    except ClassNotFound:
+        style = pygments.styles.get_style_by_name("native").styles
+
+    for token in cli_style:
+        if token.startswith("Token."):
+            token_type, style_value = parse_pygments_style(token, style, cli_style)
+            style.update({token_type: style_value})
+        elif token in PROMPT_STYLE_TO_TOKEN:
+            token_type = PROMPT_STYLE_TO_TOKEN[token]
+            style.update({token_type: cli_style[token]})
+        elif token in OVERRIDE_STYLE_TO_TOKEN:
+            token_type = OVERRIDE_STYLE_TO_TOKEN[token]
+            style.update({token_type: cli_style[token]})
+        else:
+            # TODO: cli helpers will have to switch to ptk.Style
+            logger.error("Unhandled style / class name: %s", token)
+
+    class OutputStyle(PygmentsStyle):
+        default_style = ""
+        styles = style
+
+    return OutputStyle

mycli/clitoolbar.py

@@ -0,0 +1,52 @@
+from prompt_toolkit.key_binding.vi_state import InputMode
+from prompt_toolkit.application import get_app
+from prompt_toolkit.enums import EditingMode
+from .packages import special
+
+
+def create_toolbar_tokens_func(mycli, show_fish_help):
+    """Return a function that generates the toolbar tokens."""
+
+    def get_toolbar_tokens():
+        result = [("class:bottom-toolbar", " ")]
+
+        if mycli.multi_line:
+            delimiter = special.get_current_delimiter()
+            result.append(
+                (
+                    "class:bottom-toolbar",
+                    " ({} [{}] will end the line) ".format("Semi-colon" if delimiter == ";" else "Delimiter", delimiter),
+                )
+            )
+
+        if mycli.multi_line:
+            result.append(("class:bottom-toolbar.on", "[F3] Multiline: ON  "))
+        else:
+            result.append(("class:bottom-toolbar.off", "[F3] Multiline: OFF  "))
+        if mycli.prompt_app.editing_mode == EditingMode.VI:
+            result.append(("class:bottom-toolbar.on", "Vi-mode ({})".format(_get_vi_mode())))
+
+        if mycli.toolbar_error_message:
+            result.append(("class:bottom-toolbar", "  " + mycli.toolbar_error_message))
+            mycli.toolbar_error_message = None
+
+        if show_fish_help():
+            result.append(("class:bottom-toolbar", "  Right-arrow to complete suggestion"))
+
+        if mycli.completion_refresher.is_refreshing():
+            result.append(("class:bottom-toolbar", "     Refreshing completions..."))
+
+        return result
+
+    return get_toolbar_tokens
+
+
+def _get_vi_mode():
+    """Get the current vi mode for display."""
+    return {
+        InputMode.INSERT: "I",
+        InputMode.NAVIGATION: "N",
+        InputMode.REPLACE: "R",
+        InputMode.REPLACE_SINGLE: "R",
+        InputMode.INSERT_MULTIPLE: "M",
+    }[get_app().vi_state.input_mode]

mycli/compat.py

@@ -0,0 +1,6 @@
+"""Platform and Python version compatibility support."""
+
+import sys
+
+
+WIN = sys.platform in ("win32", "cygwin")

mycli/completion_refresher.py

@@ -0,0 +1,153 @@
+import threading
+from .packages.special.main import COMMANDS
+from collections import OrderedDict
+
+from .sqlcompleter import SQLCompleter
+from .sqlexecute import SQLExecute, ServerSpecies
+
+
+class CompletionRefresher(object):
+    refreshers = OrderedDict()
+
+    def __init__(self):
+        self._completer_thread = None
+        self._restart_refresh = threading.Event()
+
+    def refresh(self, executor, callbacks, completer_options=None):
+        """Creates a SQLCompleter object and populates it with the relevant
+        completion suggestions in a background thread.
+
+        executor - SQLExecute object, used to extract the credentials to connect
+                   to the database.
+        callbacks - A function or a list of functions to call after the thread
+                    has completed the refresh. The newly created completion
+                    object will be passed in as an argument to each callback.
+        completer_options - dict of options to pass to SQLCompleter.
+
+        """
+        if completer_options is None:
+            completer_options = {}
+
+        if self.is_refreshing():
+            self._restart_refresh.set()
+            return [(None, None, None, "Auto-completion refresh restarted.")]
+        else:
+            self._completer_thread = threading.Thread(
+                target=self._bg_refresh, args=(executor, callbacks, completer_options), name="completion_refresh"
+            )
+            self._completer_thread.daemon = True
+            self._completer_thread.start()
+            return [(None, None, None, "Auto-completion refresh started in the background.")]
+
+    def is_refreshing(self):
+        return self._completer_thread and self._completer_thread.is_alive()
+
+    def _bg_refresh(self, sqlexecute, callbacks, completer_options):
+        completer = SQLCompleter(**completer_options)
+
+        # Create a new pgexecute method to populate the completions.
+        e = sqlexecute
+        executor = SQLExecute(
+            e.dbname,
+            e.user,
+            e.password,
+            e.host,
+            e.port,
+            e.socket,
+            e.charset,
+            e.local_infile,
+            e.ssl,
+            e.ssh_user,
+            e.ssh_host,
+            e.ssh_port,
+            e.ssh_password,
+            e.ssh_key_filename,
+        )
+
+        # If callbacks is a single function then push it into a list.
+        if callable(callbacks):
+            callbacks = [callbacks]
+
+        while 1:
+            for refresher in self.refreshers.values():
+                refresher(completer, executor)
+                if self._restart_refresh.is_set():
+                    self._restart_refresh.clear()
+                    break
+            else:
+                # Break out of while loop if the for loop finishes natually
+                # without hitting the break statement.
+                break
+
+            # Start over the refresh from the beginning if the for loop hit the
+            # break statement.
+            continue
+
+        for callback in callbacks:
+            callback(completer)
+
+
+def refresher(name, refreshers=CompletionRefresher.refreshers):
+    """Decorator to add the decorated function to the dictionary of
+    refreshers. Any function decorated with a @refresher will be executed as
+    part of the completion refresh routine."""
+
+    def wrapper(wrapped):
+        refreshers[name] = wrapped
+        return wrapped
+
+    return wrapper
+
+
+@refresher("databases")
+def refresh_databases(completer, executor):
+    completer.extend_database_names(executor.databases())
+
+
+@refresher("schemata")
+def refresh_schemata(completer, executor):
+    # schemata - In MySQL Schema is the same as database. But for mycli
+    # schemata will be the name of the current database.
+    completer.extend_schemata(executor.dbname)
+    completer.set_dbname(executor.dbname)
+
+
+@refresher("tables")
+def refresh_tables(completer, executor):
+    table_columns_dbresult = list(executor.table_columns())
+    completer.extend_relations(table_columns_dbresult, kind="tables")
+    completer.extend_columns(table_columns_dbresult, kind="tables")
+
+
+@refresher("users")
+def refresh_users(completer, executor):
+    completer.extend_users(executor.users())
+
+
+# @refresher('views')
+# def refresh_views(completer, executor):
+#     completer.extend_relations(executor.views(), kind='views')
+#     completer.extend_columns(executor.view_columns(), kind='views')
+
+
+@refresher("functions")
+def refresh_functions(completer, executor):
+    completer.extend_functions(executor.functions())
+    if executor.server_info.species == ServerSpecies.TiDB:
+        completer.extend_functions(completer.tidb_functions, builtin=True)
+
+
+@refresher("special_commands")
+def refresh_special(completer, executor):
+    completer.extend_special_commands(COMMANDS.keys())
+
+
+@refresher("show_commands")
+def refresh_show_commands(completer, executor):
+    completer.extend_show_items(executor.show_candidates())
+
+
+@refresher("keywords")
+def refresh_keywords(completer, executor):
+    if executor.server_info.species == ServerSpecies.TiDB:
+        completer.extend_keywords(completer.tidb_keywords, replace=True)