././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1762004092.3018172 mycli-1.41.0/0000755000175100017510000000000015101406174012357 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/.coveragerc0000644000175100017510000000002515101406164014474 0ustar00runnerrunner[run] source = mycli ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/.git-blame-ignore-revs0000644000175100017510000000000015101406164016444 0ustar00runnerrunner././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1762004092.2808173 mycli-1.41.0/.github/0000755000175100017510000000000015101406174013717 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/.github/PULL_REQUEST_TEMPLATE.md0000644000175100017510000000066515101406164017526 0ustar00runnerrunner## Description ## Checklist - [ ] I've added this contribution to the `changelog.md`. - [ ] I've added my name to the `AUTHORS` file (or it's already there). - [ ] I ran `uv run ruff check && uv run ruff format && uv run mypy --install-types .` to lint and format the code. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/.github/dependabot.yml0000644000175100017510000000016515101406164016550 0ustar00runnerrunnerversion: 2 updates: - package-ecosystem: "github-actions" directory: "/" schedule: interval: "daily" ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1762004092.2808173 mycli-1.41.0/.github/workflows/0000755000175100017510000000000015101406174015754 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/.github/workflows/ci.yml0000644000175100017510000000436215101406164017076 0ustar00runnerrunnername: CI on: pull_request: paths-ignore: - '**.md' - 'AUTHORS' jobs: tests: name: Tests runs-on: ubuntu-latest strategy: fail-fast: false matrix: python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"] steps: - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0 - uses: astral-sh/setup-uv@85856786d1ce8acfbcc2f13a5f3fbd6b938f9f41 # v7.1.2 with: version: "latest" - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0 with: python-version: ${{ matrix.python-version }} - name: Start MySQL run: | sudo /etc/init.d/mysql start - name: Install dependencies run: uv sync --all-extras -p ${{ matrix.python-version }} - name: Wait for MySQL connection run: | while ! mysqladmin ping --host=localhost --port=3306 --user=root --password=root --silent; do sleep 5 done - name: Pytest / behave env: PYTEST_PASSWORD: root PYTEST_HOST: 127.0.0.1 TERM: xterm run: | uv run tox -e py${{ matrix.python-version }} test-no-extras: name: Tests Without Extras runs-on: ubuntu-latest steps: - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0 - uses: astral-sh/setup-uv@85856786d1ce8acfbcc2f13a5f3fbd6b938f9f41 # v7.1.2 with: version: "latest" - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0 with: python-version: '3.13' - name: Start MySQL run: | sudo /etc/init.d/mysql start - name: Install dependencies run: uv sync --extra dev -p python3.13 - name: Wait for MySQL connection run: | while ! mysqladmin ping --host=localhost --port=3306 --user=root --password=root --silent; do sleep 5 done - name: Pytest / behave env: PYTEST_PASSWORD: root PYTEST_HOST: 127.0.0.1 TERM: xterm run: | uv run tox -e py3.13 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/.github/workflows/lint.yml0000644000175100017510000000141315101406164017443 0ustar00runnerrunnername: Lint on: pull_request: paths-ignore: - '**.md' - 'AUTHORS' jobs: linters: name: Linters runs-on: ubuntu-latest steps: - name: Check out Git repository uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0 # remember to sync the ruff-check version number with pyproject.toml - name: Run ruff check uses: astral-sh/ruff-action@57714a7c8a2e59f32539362ba31877a1957dded1 # v3.5.1 with: version: 0.11.5 # remember to sync the ruff-check version number with pyproject.toml - name: Run ruff format uses: astral-sh/ruff-action@57714a7c8a2e59f32539362ba31877a1957dded1 # v3.5.1 with: version: 0.11.5 args: 'format --check' ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/.github/workflows/publish.yml0000644000175100017510000000534415101406164020152 0ustar00runnerrunnername: Publish Python Package on: release: types: [created] permissions: contents: read jobs: docs: runs-on: ubuntu-latest steps: - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0 - name: Require release changelog form run: | if grep -q TBD changelog.md; then false; fi test: runs-on: ubuntu-latest needs: [docs] strategy: matrix: python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"] steps: - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0 - uses: astral-sh/setup-uv@85856786d1ce8acfbcc2f13a5f3fbd6b938f9f41 # v7.1.2 with: version: "latest" - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0 with: python-version: ${{ matrix.python-version }} - name: Start MySQL run: | sudo /etc/init.d/mysql start - name: Install dependencies run: uv sync --all-extras -p ${{ matrix.python-version }} - name: Wait for MySQL connection run: | while ! mysqladmin ping --host=localhost --port=3306 --user=root --password=root --silent; do sleep 5 done - name: Pytest / behave env: PYTEST_PASSWORD: root PYTEST_HOST: 127.0.0.1 run: | uv run tox -e py${{ matrix.python-version }} # arguably this should be made identical to CI for PRs - name: Run Style Checks run: uv run tox -e style build: runs-on: ubuntu-latest needs: [test] steps: - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0 - uses: astral-sh/setup-uv@85856786d1ce8acfbcc2f13a5f3fbd6b938f9f41 # v7.1.2 with: version: "latest" - name: Set up Python uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0 with: python-version: '3.13' - name: Install dependencies run: uv sync --all-extras -p 3.13 - name: Build run: uv build - name: Store the distribution packages uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0 with: name: python-packages path: dist/ publish: name: Publish to PyPI runs-on: ubuntu-latest if: startsWith(github.ref, 'refs/tags/') needs: [build] environment: release permissions: id-token: write steps: - name: Download distribution packages uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0 with: name: python-packages path: dist/ - name: Publish to PyPI uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # v1.13.0 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/.github/workflows/typecheck.yml0000644000175100017510000000151515101406164020457 0ustar00runnerrunnername: Typecheck on: pull_request: paths-ignore: - '**.md' - 'AUTHORS' jobs: typecheck: name: Typecheck runs-on: ubuntu-latest steps: - name: Check out Git repository uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0 - name: Set up Python uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0 with: python-version: '3.13' - uses: astral-sh/setup-uv@85856786d1ce8acfbcc2f13a5f3fbd6b938f9f41 # v7.1.2 with: version: 'latest' - name: Install dependencies run: uv sync --all-extras - name: Run mypy run: | uv run --no-sync --frozen -- python -m ensurepip uv run --no-sync --frozen -- python -m mypy --no-pretty --install-types --non-interactive . ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/.gitignore0000644000175100017510000000020515101406164014343 0ustar00runnerrunner.idea/ .vscode/ /build /dist /mycli.egg-info /src /test/behave.ini .vagrant *.pyc *.deb .cache/ .coverage .coverage.* .venv/ venv/ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/AUTHORS.rst0000644000175100017510000000006615101406164014237 0ustar00runnerrunnerCheck out our `AUTHORS`_. .. _AUTHORS: mycli/AUTHORS ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/CONTRIBUTING.md0000644000175100017510000000575315101406164014621 0ustar00runnerrunner# Development Guide This is a guide for developers who would like to contribute to this project. If you're interested in contributing to mycli, thank you. We'd love your help! You'll always get credit for your work. ## GitHub Workflow 1. [Fork the repository](https://github.com/dbcli/mycli) on GitHub. 2. Clone your fork locally: ```bash $ git clone ``` 3. Add the official repository (`upstream`) as a remote repository: ```bash $ git remote add upstream git@github.com:dbcli/mycli.git ``` 4. Set up [uv](https://docs.astral.sh/uv/getting-started/installation/) for development: ```bash $ cd mycli $ uv sync --extra dev ``` We've just created a virtual environment and installed all the dependencies and tools we need to work on mycli. 5. Create a branch for your bugfix or feature based off the `main` branch: ```bash $ git checkout -b main ``` 6. While you work on your bugfix or feature, be sure to pull the latest changes from `upstream`. This ensures that your local codebase is up-to-date: ```bash $ git pull upstream main ``` 7. When your work is ready for the mycli team to review it, push your branch to your fork: ```bash $ git push origin ``` 8. [Create a pull request](https://help.github.com/articles/creating-a-pull-request-from-a-fork/) on GitHub. ## Running mycli To run mycli with your local changes: ```bash $ uv run mycli ``` ## Running the Tests While you work on mycli, it's important to run the tests to make sure your code hasn't broken any existing functionality. To run the tests, just type in: ```bash $ uv run tox ``` ### Test Database Credentials Some tests require a database connection to work. You can tell the tests which credentials to use by setting the applicable environment variables: ```bash $ export PYTEST_HOST=localhost $ export PYTEST_USER=mycli $ export PYTEST_PASSWORD=myclirocks $ export PYTEST_PORT=3306 $ export PYTEST_CHARSET=utf8 ``` The default values are `localhost`, `root`, no password, `3306`, and `utf8`. You only need to set the values that differ from the defaults. If you would like to run the tests as a user with only the necessary privileges, create a `mycli` user and run the following grant statements. ```sql GRANT ALL PRIVILEGES ON `mycli_%`.* TO 'mycli'@'localhost'; GRANT SELECT ON mysql.* TO 'mycli'@'localhost'; GRANT SELECT ON performance_schema.* TO 'mycli'@'localhost'; ``` ### CLI Tests Some CLI tests expect the program `ex` to be a symbolic link to `vim`. In some systems (e.g. Arch Linux) `ex` is a symbolic link to `vi`, which will change the output and therefore make some tests fail. You can check this by running: ```bash $ readlink -f $(which ex) ``` ## Releasing a new version of mycli Create a new [release](https://github.com/dbcli/mycli/releases) in Github. This will trigger a Github action which will run all the tests, build the wheel and upload it to PyPI. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/LICENSE.txt0000644000175100017510000000335315101406164014205 0ustar00runnerrunnerAll rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ------------------------------------------------------------------------------- This program also bundles with it python-tabulate (https://pypi.python.org/pypi/tabulate) library. This library is licensed under MIT License. ------------------------------------------------------------------------------- ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/MANIFEST.in0000644000175100017510000000031115101406164014107 0ustar00runnerrunnerinclude LICENSE.txt *.md *.rst screenshots/* include tasks.py .coveragerc tox.ini recursive-include test *.cnf recursive-include test *.feature recursive-include test *.py recursive-include test *.txt ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1762004092.3008173 mycli-1.41.0/PKG-INFO0000644000175100017510000001360615101406174013462 0ustar00runnerrunnerMetadata-Version: 2.4 Name: mycli Version: 1.41.0 Summary: CLI for MySQL Database. With auto-completion and syntax highlighting. Author-email: Mycli Core Team License-Expression: BSD-3-Clause Project-URL: homepage, http://mycli.net Requires-Python: >=3.10 Description-Content-Type: text/markdown License-File: LICENSE.txt License-File: AUTHORS.rst Requires-Dist: click<8.1.8,>=7.0 Requires-Dist: cryptography>=1.0.0 Requires-Dist: Pygments>=1.6 Requires-Dist: prompt_toolkit<4.0.0,>=3.0.6 Requires-Dist: PyMySQL>=0.9.2 Requires-Dist: sqlparse<0.6.0,>=0.3.0 Requires-Dist: sqlglot[rs]==27.* Requires-Dist: configobj>=5.0.5 Requires-Dist: cli_helpers[styles]>=2.7.0 Requires-Dist: pyperclip>=1.8.1 Requires-Dist: pycryptodomex Requires-Dist: pyfzf>=0.3.1 Provides-Extra: ssh Requires-Dist: paramiko; extra == "ssh" Requires-Dist: sshtunnel; extra == "ssh" Provides-Extra: llm Requires-Dist: llm>=0.19.0; extra == "llm" Requires-Dist: setuptools; extra == "llm" Requires-Dist: pip; extra == "llm" Provides-Extra: all Requires-Dist: mycli[ssh]; extra == "all" Requires-Dist: mycli[llm]; extra == "all" Provides-Extra: dev Requires-Dist: behave>=1.2.6; extra == "dev" Requires-Dist: coverage>=7.2.7; extra == "dev" Requires-Dist: mypy>=1.16.1; extra == "dev" Requires-Dist: pexpect>=4.9.0; extra == "dev" Requires-Dist: pytest>=7.4.4; extra == "dev" Requires-Dist: pytest-cov>=4.1.0; extra == "dev" Requires-Dist: tox>=4.8.0; extra == "dev" Requires-Dist: pdbpp>=0.10.3; extra == "dev" Requires-Dist: paramiko; extra == "dev" Requires-Dist: sshtunnel; extra == "dev" Requires-Dist: llm>=0.19.0; extra == "dev" Requires-Dist: setuptools; extra == "dev" Requires-Dist: pip; extra == "dev" Dynamic: license-file # mycli [![Build Status](https://github.com/dbcli/mycli/workflows/mycli/badge.svg)](https://github.com/dbcli/mycli/actions?query=workflow%3Amycli) A command line client for MySQL that can do auto-completion and syntax highlighting. Homepage: [http://mycli.net](http://mycli.net) Documentation: [http://mycli.net/docs](http://mycli.net/docs) ![Completion](screenshots/tables.png) ![CompletionGif](screenshots/main.gif) Postgres Equivalent: [http://pgcli.com](http://pgcli.com) Quick Start ----------- If you already know how to install Python packages, then you can install it via `pip`: You might need sudo on Linux. ```bash pip install -U 'mycli[all]' ``` or ```bash brew update && brew install mycli # Only on macOS ``` or ```bash sudo apt-get install mycli # Only on Debian or Ubuntu ``` ### Usage See ```bash mycli --help ``` Features -------- `mycli` is written using [prompt_toolkit](https://github.com/jonathanslenders/python-prompt-toolkit/). * Auto-completion as you type for SQL keywords as well as tables, views and columns in the database. * Syntax highlighting using Pygments. * Smart-completion (enabled by default) will suggest context-sensitive completion. - `SELECT * FROM ` will only show table names. - `SELECT * FROM users WHERE ` will only show column names. * Support for multiline queries. * Favorite queries with optional positional parameters. Save a query using `\fs alias query` and execute it with `\f alias` whenever you need. * Timing of sql statements and table rendering. * Config file is automatically created at ``~/.myclirc`` at first launch. * Log every query and its results to a file (disabled by default). * Pretty prints tabular data (with colors!) * Support for SSL connections * Shell-style trailing redirects with `$>`, `$>>` and `$|` operators. * Some features are only exposed as [key bindings](doc/key_bindings.rst) Contributions: -------------- If you're interested in contributing to this project, first of all I would like to extend my heartfelt gratitude. I've written a small doc to describe how to get this running in a development setup. https://github.com/dbcli/mycli/blob/main/CONTRIBUTING.md ## Additional Install Instructions: These are some alternative ways to install mycli that are not managed by our team but provided by OS package maintainers. These packages could be slightly out of date and take time to release the latest version. ### Arch, Manjaro You can install the mycli package available in the AUR: ``` yay -S mycli ``` ### Debian, Ubuntu On Debian, Ubuntu distributions, you can easily install the mycli package using apt: ``` sudo apt-get install mycli ``` ### Fedora Fedora has a package available for mycli, install it using dnf: ``` sudo dnf install mycli ``` ### Windows Follow the instructions on this blogpost: http://web.archive.org/web/20221006045208/https://www.codewall.co.uk/installing-using-mycli-on-windows/ ### Thanks: This project was funded through kickstarter. My thanks to the [backers](http://mycli.net/sponsors) who supported the project. A special thanks to [Jonathan Slenders](https://twitter.com/jonathan_s) for creating [Python Prompt Toolkit](http://github.com/jonathanslenders/python-prompt-toolkit), which is quite literally the backbone library, that made this app possible. Jonathan has also provided valuable feedback and support during the development of this app. [Click](http://click.pocoo.org/) is used for command line option parsing and printing error messages. Thanks to [PyMysql](https://github.com/PyMySQL/PyMySQL) for a pure python adapter to MySQL database. ### Compatibility Mycli is tested on macOS and Linux, and requires Python 3.10 or better. **Mycli is not tested on Windows**, but the libraries used in this app are Windows-compatible. This means it should work without any modifications. If you're unable to run it on Windows, please [file a bug](https://github.com/dbcli/mycli/issues/new). ### Configuration and Usage For more information on using and configuring mycli, [check out our documentation](http://mycli.net/docs). Common topics include: - [Configuring mycli](http://mycli.net/config) - [Using/Disabling the pager](http://mycli.net/pager) - [Syntax colors](http://mycli.net/syntax) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/README.md0000644000175100017510000001030015101406164013627 0ustar00runnerrunner# mycli [![Build Status](https://github.com/dbcli/mycli/workflows/mycli/badge.svg)](https://github.com/dbcli/mycli/actions?query=workflow%3Amycli) A command line client for MySQL that can do auto-completion and syntax highlighting. Homepage: [http://mycli.net](http://mycli.net) Documentation: [http://mycli.net/docs](http://mycli.net/docs) ![Completion](screenshots/tables.png) ![CompletionGif](screenshots/main.gif) Postgres Equivalent: [http://pgcli.com](http://pgcli.com) Quick Start ----------- If you already know how to install Python packages, then you can install it via `pip`: You might need sudo on Linux. ```bash pip install -U 'mycli[all]' ``` or ```bash brew update && brew install mycli # Only on macOS ``` or ```bash sudo apt-get install mycli # Only on Debian or Ubuntu ``` ### Usage See ```bash mycli --help ``` Features -------- `mycli` is written using [prompt_toolkit](https://github.com/jonathanslenders/python-prompt-toolkit/). * Auto-completion as you type for SQL keywords as well as tables, views and columns in the database. * Syntax highlighting using Pygments. * Smart-completion (enabled by default) will suggest context-sensitive completion. - `SELECT * FROM ` will only show table names. - `SELECT * FROM users WHERE ` will only show column names. * Support for multiline queries. * Favorite queries with optional positional parameters. Save a query using `\fs alias query` and execute it with `\f alias` whenever you need. * Timing of sql statements and table rendering. * Config file is automatically created at ``~/.myclirc`` at first launch. * Log every query and its results to a file (disabled by default). * Pretty prints tabular data (with colors!) * Support for SSL connections * Shell-style trailing redirects with `$>`, `$>>` and `$|` operators. * Some features are only exposed as [key bindings](doc/key_bindings.rst) Contributions: -------------- If you're interested in contributing to this project, first of all I would like to extend my heartfelt gratitude. I've written a small doc to describe how to get this running in a development setup. https://github.com/dbcli/mycli/blob/main/CONTRIBUTING.md ## Additional Install Instructions: These are some alternative ways to install mycli that are not managed by our team but provided by OS package maintainers. These packages could be slightly out of date and take time to release the latest version. ### Arch, Manjaro You can install the mycli package available in the AUR: ``` yay -S mycli ``` ### Debian, Ubuntu On Debian, Ubuntu distributions, you can easily install the mycli package using apt: ``` sudo apt-get install mycli ``` ### Fedora Fedora has a package available for mycli, install it using dnf: ``` sudo dnf install mycli ``` ### Windows Follow the instructions on this blogpost: http://web.archive.org/web/20221006045208/https://www.codewall.co.uk/installing-using-mycli-on-windows/ ### Thanks: This project was funded through kickstarter. My thanks to the [backers](http://mycli.net/sponsors) who supported the project. A special thanks to [Jonathan Slenders](https://twitter.com/jonathan_s) for creating [Python Prompt Toolkit](http://github.com/jonathanslenders/python-prompt-toolkit), which is quite literally the backbone library, that made this app possible. Jonathan has also provided valuable feedback and support during the development of this app. [Click](http://click.pocoo.org/) is used for command line option parsing and printing error messages. Thanks to [PyMysql](https://github.com/PyMySQL/PyMySQL) for a pure python adapter to MySQL database. ### Compatibility Mycli is tested on macOS and Linux, and requires Python 3.10 or better. **Mycli is not tested on Windows**, but the libraries used in this app are Windows-compatible. This means it should work without any modifications. If you're unable to run it on Windows, please [file a bug](https://github.com/dbcli/mycli/issues/new). ### Configuration and Usage For more information on using and configuring mycli, [check out our documentation](http://mycli.net/docs). Common topics include: - [Configuring mycli](http://mycli.net/config) - [Using/Disabling the pager](http://mycli.net/pager) - [Syntax colors](http://mycli.net/syntax) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/SPONSORS.rst0000644000175100017510000000007115101406164014374 0ustar00runnerrunnerCheck out our `SPONSORS`_. .. _SPONSORS: mycli/SPONSORS ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/changelog.md0000644000175100017510000011171215101406164014632 0ustar00runnerrunner1.41.0 (2025/11/01) ============== Features -------- * Make LLM dependencies an optional extra. Bug Fixes -------- * Let LLM commands respect show-timing configuration. Internal -------- * Add mypy to Pull Request template. * Enable flake8-bugbear lint rules. * Fix flaky editor-command tests in CI. * Require release format of `changelog.md` when making a release. * Improve type annotations on LLM driver. 1.40.0 (2025/10/14) ============== Features -------- * Support reconnecting to mysql server when the server restarts. Internal -------- * Test on Python 3.14. * Switch from pyaes to pycryptodomex as it seems to be more actively maintained. 1.39.1 (2025/10/06) ============== Bug Fixes -------- * Don't require `--ssl` argument when other SSL arguments are given. 1.39.0 (2025/09/30) ============== Features -------- * Support only Python 3.10+. Bug Fixes -------- * Fixes use of incorrect ssl config after retrying connection with prompted password. * Fix ssl_context always created. Internal -------- Typing fix for `pymysql.connect()`. 1.38.4 (2025/09/06) ============== Bug Fixes -------- * Limit Alt-R bindings to Emacs mode. * Fix timing being printed twice. Internal -------- * Only read "my" configuration files once, rather than once per call to read_my_cnf_files. 1.38.3 (2025/08/21) ============== Bug Fixes -------- * Fix the infinite looping when `\llm` is called without args. 1.38.2 (2025/08/19) ====================== Bug Fixes -------- * Fix failure to save Favorite Queries. 1.38.1 (2025/08/19) ====================== Bug Fixes -------- * Partially fix Favorite Query completion crash. Internal -------- * Improve CI workflow naming. 1.38.0 (2025/08/16) ====================== Features -------- * Add LLM support. Bug Fixes -------- * Improve missing ssh-extras message. * Fix repeated control-r in traditional reverse isearch. * Fix spelling of `ssl-verify-server-cert` option. * Improve handling of `ssl-verify-server-cert` False values. * Guard against missing contributors file on startup. * Friendlier errors on password-file failures. * Better handle empty-string passwords. * Permit empty-string passwords at the interactive prompt. Internal -------- * Improve pull request template lint commands. * Complete typehinting the non-test codebase. * Modernization: conversion to f-strings. * Modernization: remove more Python 2 compatibility logic. 1.37.1 (2025/07/28) ====================== Internal -------- * Align LICENSE with SPDX format. * Fix deprecated `license` specification format in `pyproject.toml`. 1.37.0 (2025/07/28) ====================== Features -------- * Show username in password prompt. * Add `mysql` and `mysql_unicode` table formats. Bug Fixes -------- * Help Windows installations find a working default pager. Internal -------- * Support only Python 3.9+ in `pyproject.toml`. * Add linting suggestion to pull request template. * Make CI names and properties more consistent. * Enable typechecking for most of the non-test codebase. * CI: turn off fail-fast matrix strategy. * Remove unused Python 2 compatibility code. * Also run CI tests without installing SSH extra dependencies. * Update `cli_helpers` dependency, and list of table formats. 1.36.0 (2025/07/19) ====================== Features -------- * Make control-r reverse search style configurable. * Make fzf search key bindings more compatible with traditional isearch. Bug Fixes -------- * Better reset after pipe command failures. Internal -------- * Add limited typechecking to CI. 1.35.0 (2025/07/18) ====================== Features -------- * Support chained pipe operators such as `select first_name from users $| grep '^J' $| head -10`. * Support trailing file redirects after pipe operators, such as `select 10 $| tail -1 $> ten.txt`. 1.34.4 (2025/07/15) ====================== Bug Fixes -------- * Fix old-style `\pipe_once`. 1.34.3 (2025/07/14) ====================== Bug Fixes -------- * Use only `communicate()` to communicate with subprocess. 1.34.2 (2025/07/12) ====================== Bug Fixes -------- * Use plain `print()` to communicate with subprocess. 1.34.1 (2025/07/12) ====================== Internal -------- * Bump cli_helpers dependency for corrected output formats. 1.34.0 (2025/07/11) ====================== Features -------- * Post-save command hook for redirected output. Internal -------- * Documentation cleanup. * Bump cli_helpers dependency for more output formats. 1.33.0 (2025/07/07) ====================== Features -------- * Keybindings to insert current date/datetime. * Improve feedback when running external commands. * Independent format for redirected output. * Trailing shell-style redirect syntax. Internal -------- * Remove `requirements-dev.txt` in favor of uv/`pyproject.toml`. 1.32.0 (2025/07/04) ====================== Features -------- * Support SSL query parameters on DSNs. * More information and care on KeyboardInterrupt. Internal -------- * Work on passing `ruff check` linting. * Relax expectation for unreliable test. * Bump sqlglot version to v26 and add rs extras. 1.31.2 (2025/05/01) =================== Bug Fixes --------- * Let table-name extraction work on multi-statement inputs. Internal -------- * Work on passing `ruff check` linting. * Remove backward-compatibility hacks. * Pin more GitHub Actions and add Dependabot support. * Enable xpassing test. 1.31.1 (2025/04/25) =================== Internal -------- * skip style checks on Publish action 1.31.0 (NEVER RELEASED) =================== Features -------- * Added explicit error handle to get_password_from_file with EAFP. * Use the "history" scheme for fzf searches. * Deduplicate history in fzf searches. * Add a preview window to fzf history searches. Internal -------- * New Project Lead: [Roland Walker](https://github.com/rolandwalker) * Update sqlparse to <=0.6.0 * Typing/lint fixes. 1.30.0 (2025/04/19) =================== Features -------- * DSN specific init-command in myclirc. Fixes (#1195) * Add `\\g` to force the horizontal output. 1.29.2 (2024/12/11) =================== Internal -------- * Exclude tests from the python package. 1.29.1 (2024/12/11) =================== Internal -------- * Fix the GH actions to publish a new version. 1.29.0 (NEVER RELEASED) ======================= Bug Fixes ---------- * fix SSL through SSH jump host by using a true python socket for a tunnel * Fix mycli crash when connecting to Vitess Internal --------- * Modernize to use PEP-621. Use `uv` instead of `pip` in GH actions. * Remove Python 3.8 and add Python 3.13 in test matrix. 1.28.0 (2024/11/10) ====================== Features --------- * Added fzf history search functionality. The feature can switch between the old implementation and the new one based on the presence of the fzf binary. Bug Fixes ---------- * Fixes `Database connection failed: error('unpack requires a buffer of 4 bytes')` * Only show keyword completions after * * Enable fuzzy matching for keywords 1.27.2 (2024/04/03) =================== Bug Fixes ---------- * Don't use default prompt when one is not supplied to the --prompt option. 1.27.1 (2024/03/28) =================== Bug Fixes ---------- * Don't install tests. * Do not ignore the socket passed with the -S option, even when no port is passed * Fix unexpected exception when using dsn without username & password (Thanks: [Will Wang]) * Let the `--prompt` option act normally with its predefined default value Internal --------- * paramiko is newer than 2.11.0 now, remove version pinning `cryptography`. * Drop support for Python 3.7 1.27.0 (2023/08/11) =================== Features --------- * Detect TiDB instance, show in the prompt, and use additional keywords. * Fix the completion order to show more commonly-used keywords at the top. Bug Fixes ---------- * Better handle empty statements in un/prettify * Remove vi-mode bindings for prettify/unprettify. * Honor `\G` when executing from commandline with `-e`. * Correctly report the version of TiDB. * Revised `botton` spelling mistakes with `bottom` in `mycli/clitoolbar.py` 1.26.1 (2022/09/01) =================== Bug Fixes ---------- * Require Python 3.7 in `setup.py` 1.26.0 (2022/09/01) =================== Features --------- * Add `--ssl` flag to enable ssl/tls. * Add `pager` option to `~/.myclirc`, for instance `pager = 'pspg --csv'` (Thanks: [BuonOmo]) * Add prettify/unprettify keybindings to format the current statement using `sqlglot`. Features --------- * Add `--tls-version` option to control the tls version used. Internal --------- * Pin `cryptography` to suppress `paramiko` warning, helping CI complete and presumably affecting some users. * Upgrade some dev requirements * Change tests to always use databases prefixed with 'mycli_' for better security Bug Fixes ---------- * Support for some MySQL compatible databases, which may not implement connection_id(). * Fix the status command to work with missing 'Flush_commands' (mariadb) * Ignore the user of the system [myslqd] config. 1.25.0 (2022/04/02) =================== Features --------- * Add `beep_after_seconds` option to `~/.myclirc`, to ring the terminal bell after long queries. 1.24.4 (2022/03/30) =================== Internal --------- * Upgrade Ubuntu VM for runners as Github has deprecated it Bug Fixes ---------- * Change in main.py - Replace the `click.get_terminal_size()` with `shutil.get_terminal_size()` 1.24.3 (2022/01/20) =================== Bug Fixes ---------- * Upgrade cli_helpers to workaround Pygments regression. 1.24.2 (2022/01/11) =================== Bug Fixes ---------- * Fix autocompletion for more than one JOIN * Fix the status command when connected to TiDB or other servers that don't implement 'Threads\_connected' * Pin pygments version to avoid a breaking change 1.24.1 ======= Bug Fixes --------- * Restore dependency on cryptography for the interactive password prompt Internal --------- * Deprecate Python mock 1.24.0 ====== Bug Fixes ---------- * Allow `FileNotFound` exception for SSH config files. * Fix startup error on MySQL < 5.0.22 * Check error code rather than message for Access Denied error * Fix login with ~/.my.cnf files Features --------- * Add `-g` shortcut to option `--login-path`. * Alt-Enter dispatches the command in multi-line mode. * Allow to pass a file or FIFO path with --password-file when password is not specified or is failing (as suggested in this best-practice ) Internal --------- * Remove unused function is_open_quote() * Use importlib, instead of file links, to locate resources * Test various host-port combinations in command line arguments * Switched from Cryptography to pyaes for decrypting mylogin.cnf 1.23.2 ====== Bug Fixes ---------- * Ensure `--port` is always an int. 1.23.1 ====== Bug Fixes ---------- * Allow `--host` without `--port` to make a TCP connection. 1.23.0 ====== Bug Fixes ---------- * Fix config file include logic Features --------- * Add an option `--init-command` to execute SQL after connecting (Thanks: [KITAGAWA Yasutaka]). * Use InputMode.REPLACE_SINGLE * Add support for ANSI escape sequences for coloring the prompt. * Allow customization of Pygments SQL syntax-highlighting styles. * Add a `\clip` special command to copy queries to the system clipboard. * Add a special command `\pipe_once` to pipe output to a subprocess. * Add an option `--charset` to set the default charset when connect database. Bug Fixes ---------- * Fixed compatibility with sqlparse 0.4 (Thanks: [mtorromeo]). * Fixed iPython magic (Thanks: [mwcm]). * Send "Connecting to socket" message to the standard error. * Respect empty string for prompt_continuation via `prompt_continuation = ''` in `.myclirc` * Fix \once -o to overwrite output whole, instead of line-by-line. * Dispatch lines ending with `\e` or `\clip` on return, even in multiline mode. * Restore working local `--socket=` (Thanks: [xeron]). * Allow backtick quoting around the database argument to the `use` command. * Avoid opening `/dev/tty` when `--no-warn` is given. * Fixed some typo errors in `README.md`. 1.22.2 ====== Bug Fixes ---------- * Make the `pwd` module optional. 1.22.1 ====== Bug Fixes ---------- * Fix the breaking change introduced in PyMySQL 0.10.0. (Thanks: [Amjith]). Features --------- * Add an option `--ssh-config-host` to read ssh configuration from OpenSSH configuration file. * Add an option `--list-ssh-config` to list ssh configurations. * Add an option `--ssh-config-path` to choose ssh configuration path. Bug Fixes ---------- * Fix specifying empty password with `--password=''` when config file has a password set (Thanks: [Zach DeCook]). 1.21.1 ====== Bug Fixes ---------- * Fix broken auto-completion for favorite queries (Thanks: [Amjith]). * Fix undefined variable exception when running with --no-warn (Thanks: [Georgy Frolov]) * Support setting color for null value (Thanks: [laixintao]) 1.21.0 ====== Features --------- * Added DSN alias name as a format specifier to the prompt (Thanks: [Georgy Frolov]). * Mark `update` without `where`-clause as destructive query (Thanks: [Klaus Wünschel]). * Added DELIMITER command (Thanks: [Georgy Frolov]) * Added clearer error message when failing to connect to the default socket. * Extend main.is_dropping_database check with create after delete statement. * Search `${XDG_CONFIG_HOME}/mycli/myclirc` after `${HOME}/.myclirc` and before `/etc/myclirc` (Thanks: [Takeshi D. Itoh]) Bug Fixes ---------- * Allow \o command more than once per session (Thanks: [Georgy Frolov]) * Fixed crash when the query dropping the current database starts with a comment (Thanks: [Georgy Frolov]) Internal --------- * deprecate python versions 2.7, 3.4, 3.5; support python 3.8 1.20.1 ====== Bug Fixes ---------- * Fix an error when using login paths with an explicit database name (Thanks: [Thomas Roten]). 1.20.0 ====== Features ---------- * Auto find alias dsn when `://` not in `database` (Thanks: [QiaoHou Peng]). * Mention URL encoding as escaping technique for special characters in connection DSN (Thanks: [Aljosha Papsch]). * Pressing Alt-Enter will introduce a line break. This is a way to break up the query into multiple lines without switching to multi-line mode. (Thanks: [Amjith Ramanujam]). * Use a generator to stream the output to the pager (Thanks: [Dick Marinus]). Bug Fixes ---------- * Fix the missing completion for special commands (Thanks: [Amjith Ramanujam]). * Fix favorites queries being loaded/stored only from/in default config file and not --myclirc (Thanks: [Matheus Rosa]) * Fix automatic vertical output with native syntax style (Thanks: [Thomas Roten]). * Update `cli_helpers` version, this will remove quotes from batch output like the official client (Thanks: [Dick Marinus]) * Update `setup.py` to no longer require `sqlparse` to be less than 0.3.0 as that just came out and there are no notable changes. ([VVelox]) * workaround for ConfigObj parsing strings containing "," as lists (Thanks: [Mike Palandra]) Internal --------- * fix unhashable FormattedText from prompt toolkit in unit tests (Thanks: [Dick Marinus]). 1.19.0 ====== Internal --------- * Add Python 3.7 trove classifier (Thanks: [Thomas Roten]). * Fix pytest in Fedora mock (Thanks: [Dick Marinus]). * Require `prompt_toolkit>=2.0.6` (Thanks: [Dick Marinus]). Features --------- * Add Token.Prompt/Continuation (Thanks: [Dick Marinus]). * Don't reconnect when switching databases using use (Thanks: [Angelo Lupo]). * Handle MemoryErrors while trying to pipe in large files and exit gracefully with an error (Thanks: [Amjith Ramanujam]) Bug Fixes ---------- * Enable Ctrl-Z to suspend the app (Thanks: [Amjith Ramanujam]). 1.18.2 ====== Bug Fixes ---------- * Fixes database reconnecting feature (Thanks: [Yang Zou]). Internal --------- * Update Twine version to 1.12.1 (Thanks: [Thomas Roten]). * Fix warnings for running tests on Python 3.7 (Thanks: [Dick Marinus]). * Clean up and add behave logging (Thanks: [Dick Marinus]). 1.18.1 ====== Features --------- * Add Keywords: TINYINT, SMALLINT, MEDIUMINT, INT, BIGINT (Thanks: [QiaoHou Peng]). Internal --------- * Update prompt toolkit (Thanks: [Jonathan Slenders], [Irina Truong], [Dick Marinus]). 1.18.0 ====== Features --------- * Display server version in welcome message (Thanks: [Irina Truong]). * Set `program_name` connection attribute (Thanks: [Dick Marinus]). * Use `return` to terminate a generator for better Python 3.7 support (Thanks: [Zhongyang Guan]). * Add `SAVEPOINT` to SQLCompleter (Thanks: [Huachao Mao]). * Connect using a SSH transport (Thanks: [Dick Marinus]). * Add `FROM_UNIXTIME` and `UNIX_TIMESTAMP` to SQLCompleter (Thanks: [QiaoHou Peng]) * Search `${PWD}/.myclirc`, then `${HOME}/.myclirc`, lastly `/etc/myclirc` (Thanks: [QiaoHao Peng]) Bug Fixes ---------- * When DSN is used, allow overrides from mycli arguments (Thanks: [Dick Marinus]). * A DSN without password should be allowed (Thanks: [Dick Marinus]) Bug Fixes ---------- * Convert `sql_format` to unicode strings for py27 compatibility (Thanks: [Dick Marinus]). * Fixes mycli compatibility with pbr (Thanks: [Thomas Roten]). * Don't align decimals for `sql_format` (Thanks: [Dick Marinus]). Internal --------- * Use fileinput (Thanks: [Dick Marinus]). * Enable tests for Python 3.7 (Thanks: [Thomas Roten]). * Remove `*.swp` from gitignore (Thanks: [Dick Marinus]). 1.17.0 ======= Features ---------- * Add `CONCAT` to SQLCompleter and remove unused code (Thanks: [caitinggui]) * Do not quit when aborting a confirmation prompt (Thanks: [Thomas Roten]). * Add option list-dsn (Thanks: [Frederic Aoustin]). * Add verbose option for list-dsn, add tests and clean up code (Thanks: [Dick Marinus]). Bug Fixes ---------- * Add enable_pager to the config file (Thanks: [Frederic Aoustin]). * Mark `test_sql_output` as a dbtest (Thanks: [Dick Marinus]). * Don't crash if the log/history file directories don't exist (Thanks: [Thomas Roten]). * Unquote dsn username and password (Thanks: [Dick Marinus]). * Output `Password:` prompt to stderr (Thanks: [ushuz]). * Mark `alter` as a destructive query (Thanks: [Dick Marinus]). * Quote CSV fields (Thanks: [Thomas Roten]). * Fix `thanks_picker` (Thanks: [Dick Marinus]). Internal --------- * Refactor Destructive Warning behave tests (Thanks: [Dick Marinus]). 1.16.0 ======= Features --------- * Add DSN aliases to the config file (Thanks: [Frederic Aoustin]). Bug Fixes ---------- * Do not try to connect to a unix socket on Windows (Thanks: [Thomas Roten]). 1.15.0 ======= Features --------- * Add sql-update/insert output format. (Thanks: [Dick Marinus]). * Also complete aliases in WHERE. (Thanks: [Dick Marinus]). 1.14.0 ======= Features --------- * Add `watch [seconds] query` command to repeat a query every [seconds] seconds (by default 5). (Thanks: [David Caro](https://github.com/Terseus)) * Default to unix socket connection if host and port are unspecified. This simplifies authentication on some systems and matches mysql behaviour. * Add support for positional parameters to favorite queries. (Thanks: [Scrappy Soft](https://github.com/scrappysoft)) Bug Fixes ---------- * Fix source command for script in current working directory. (Thanks: [Dick Marinus]). * Fix issue where the `tee` command did not work on Python 2.7 (Thanks: [Thomas Roten]). Internal Changes ----------------- * Drop support for Python 3.3 (Thanks: [Thomas Roten]). * Make tests more compatible between different build environments. (Thanks: [David Caro]) * Merge `_on_completions_refreshed` and `_swap_completer_objects` functions (Thanks: [Dick Marinus]). 1.13.1 ======= Bug Fixes ---------- * Fix keyword completion suggestion for `SHOW` (Thanks: [Thomas Roten]). * Prevent mycli from crashing when failing to read login path file (Thanks: [Thomas Roten]). Internal Changes ----------------- * Make tests ignore user config files (Thanks: [Thomas Roten]). 1.13.0 ======= Features --------- * Add file name completion for source command (issue #500). (Thanks: [Irina Truong]). Bug Fixes ---------- * Fix UnicodeEncodeError when editing sql command in external editor (Thanks: Klaus Wünschel). * Fix MySQL4 version comment retrieval (Thanks: [François Pietka]) * Fix error that occurred when outputting JSON and NULL data (Thanks: [Thomas Roten]). 1.12.1 ======= Bug Fixes ---------- * Prevent missing MySQL help database from causing errors in completions (Thanks: [Thomas Roten]). * Fix mycli from crashing with small terminal windows under Python 2 (Thanks: [Thomas Roten]). * Prevent an error from displaying when you drop the current database (Thanks: [Thomas Roten]). Internal Changes ----------------- * Use less memory when formatting results for display (Thanks: [Dick Marinus]). * Preliminary work for a future change in outputting results that uses less memory (Thanks: [Dick Marinus]). 1.12.0 ======= Features --------- * Add fish-style auto-suggestion from history. (Thanks: [Amjith Ramanujam]) 1.11.0 ======= Features --------- * Handle reserved space for completion menu better in small windows. (Thanks: [Thomas Roten]). * Display current vi mode in toolbar. (Thanks: [Thomas Roten]). * Opening an external editor will edit the last-run query. (Thanks: [Thomas Roten]). * Output once special command. (Thanks: [Dick Marinus]). * Add special command to show create table statement. (Thanks: [Ryan Smith]) * Display all result sets returned by stored procedures (Thanks: [Thomas Roten]). * Add current time to prompt options (Thanks: [Thomas Roten]). * Output status text in a more intuitive way (Thanks: [Thomas Roten]). * Add colored/styled headers and odd/even rows (Thanks: [Thomas Roten]). * Keyword completion casing (upper/lower/auto) (Thanks: [Irina Truong]). Bug Fixes ---------- * Fixed incorrect timekeeping when running queries from a file. (Thanks: [Thomas Roten]). * Do not display time and empty line for blank queries (Thanks: [Thomas Roten]). * Fixed issue where quit command would sometimes not work (Thanks: [Thomas Roten]). * Remove shebang from main.py (Thanks: [Dick Marinus]). * Only use pager if output doesn't fit. (Thanks: [Dick Marinus]). * Support tilde user directory for output file names (Thanks: [Thomas Roten]). * Auto vertical output is a little bit better at its calculations (Thanks: [Thomas Roten]). Internal Changes ----------------- * Rename tests/ to test/. (Thanks: [Dick Marinus]). * Move AUTHORS and SPONSORS to mycli directory. (Thanks: [Terje Røsten] []). * Switch from pycryptodome to cryptography (Thanks: [Thomas Roten]). * Add pager wrapper for behave tests (Thanks: [Dick Marinus]). * Behave test source command (Thanks: [Dick Marinus]). * Test using behave the tee command (Thanks: [Dick Marinus]). * Behave fix clean up. (Thanks: [Dick Marinus]). * Remove output formatter code in favor of CLI Helpers dependency (Thanks: [Thomas Roten]). * Better handle common before/after scenarios in behave. (Thanks: [Dick Marinus]) * Added a regression test for sqlparse >= 0.2.3 (Thanks: [Dick Marinus]). * Reverted removal of temporary hack for sqlparse (Thanks: [Dick Marinus]). * Add setup.py commands to simplify development tasks (Thanks: [Thomas Roten]). * Add behave tests to tox (Thanks: [Dick Marinus]). * Add missing @dbtest to tests (Thanks: [Dick Marinus]). * Standardizes punctuation/grammar for help strings (Thanks: [Thomas Roten]). 1.10.0 ======= Features --------- * Add ability to specify alternative myclirc file. (Thanks: [Dick Marinus]). * Add new display formats for pretty printing query results. (Thanks: [Amjith Ramanujam], [Dick Marinus], [Thomas Roten]). * Add logic to shorten the default prompt if it becomes too long once generated. (Thanks: [John Sterling]). Bug Fixes ---------- * Fix external editor bug (issue #377). (Thanks: [Irina Truong]). * Fixed bug so that favorite queries can include unicode characters. (Thanks: [Thomas Roten]). * Fix requirements and remove old compatibility code (Thanks: [Dick Marinus]) * Fix bug where mycli would not start due to the thanks/credit intro text. (Thanks: [Thomas Roten]). * Use pymysql default conversions (issue #375). (Thanks: [Dick Marinus]). Internal Changes ----------------- * Upload mycli distributions in a safer manner (using twine). (Thanks: [Thomas Roten]). * Test mycli using pexpect/python-behave (Thanks: [Dick Marinus]). * Run pep8 checks in travis (Thanks: [Irina Truong]). * Remove temporary hack for sqlparse (Thanks: [Dick Marinus]). 1.9.0 ====== Features --------- * Add tee/notee commands for outputing results to a file. (Thanks: [Dick Marinus]). * Add date, port, and whitespace options to prompt configuration. (Thanks: [Matheus Rosa]). * Allow user to specify LESS pager flags. (Thanks: [John Sterling]). * Add support for auto-reconnect. (Thanks: [Jialong Liu]). * Add CSV batch output. (Thanks: [Matheus Rosa]). * Add `auto_vertical_output` config to myclirc. (Thanks: [Matheus Rosa]). * Improve Fedora install instructions. (Thanks: [Dick Marinus]). Bug Fixes ---------- * Fix crashes occuring from commands starting with #. (Thanks: [Zhidong]). * Fix broken PyMySQL link in README. (Thanks: [Daniël van Eeden]). * Add various missing keywords for highlighting and autocompletion. (Thanks: [zer09]). * Add the missing REGEXP keyword for highlighting and autocompletion. (Thanks: [cxbig]). * Fix duplicate username entries in completion list. (Thanks: [John Sterling]). * Remove extra spaces in TSV table format output. (Thanks: [Dick Marinus]). * Kill running query when interrupted via Ctrl-C. (Thanks: [chainkite]). * Read the `smart_completion` config from myclirc. (Thanks: [Thomas Roten]). Internal Changes ----------------- * Improve handling of test database credentials. (Thanks: [Dick Marinus]). * Add Python 3.6 to test environments and PyPI metadata. (Thanks: [Thomas Roten]). * Drop Python 2.6 support. (Thanks: [Thomas Roten]). * Swap pycrypto dependency for pycryptodome. (Thanks: [Michał Górny]). * Bump sqlparse version so pgcli and mycli can be installed together. (Thanks: [darikg]). 1.8.1 ====== Bug Fixes ---------- * Remove duplicate listing of DISTINCT keyword. (Thanks: [Amjith Ramanujam]). * Add an try/except for AS keyword crash. (Thanks: [Amjith Ramanujam]). * Support python-sqlparse 0.2. (Thanks: [Dick Marinus]). * Fallback to the raw object for invalid time values. (Thanks: [Amjith Ramanujam]). * Reset the show items when completion is refreshed. (Thanks: [Amjith Ramanujam]). Internal Changes ----------------- * Make the dependency of sqlparse slightly more liberal. (Thanks: [Amjith Ramanujam]). 1.8.0 ====== Features --------- * Add support for --execute/-e commandline arg. (Thanks: [Matheus Rosa]). * Add `less_chatty` config option to skip the intro messages. (Thanks: [Scrappy Soft]). * Support `MYCLI_HISTFILE` environment variable to specify where to write the history file. (Thanks: [Scrappy Soft]). * Add `prompt_continuation` config option to allow configuring the continuation prompt for multi-line queries. (Thanks: [Scrappy Soft]). * Display login-path instead of host in prompt. (Thanks: [Irina Truong]). Bug Fixes ---------- * Pin sqlparse to version 0.1.19 since the new version is breaking completion. (Thanks: [Amjith Ramanujam]). * Remove unsupported keywords. (Thanks: [Matheus Rosa]). * Fix completion suggestion inside functions with operands. (Thanks: [Irina Truong]). 1.7.0 ====== Features --------- * Add stdin batch mode. (Thanks: [Thomas Roten]). * Add warn/no-warn command-line options. (Thanks: [Thomas Roten]). * Upgrade sqlparse dependency to 0.1.19. (Thanks: [Amjith Ramanujam]). * Update features list in README.md. (Thanks: [Matheus Rosa]). * Remove extra \n in features list in README.md. (Thanks: [Matheus Rosa]). Bug Fixes ---------- * Enable history search via . (Thanks: [Amjith Ramanujam]). Internal Changes ----------------- * Upgrade `prompt_toolkit` to 1.0.0. (Thanks: [Jonathan Slenders]) 1.6.0 ====== Features --------- * Change continuation prompt for multi-line mode to match default mysql. * Add `status` command to match mysql's `status` command. (Thanks: [Thomas Roten]). * Add SSL support for `mycli`. (Thanks: [Artem Bezsmertnyi]). * Add auto-completion and highlight support for OFFSET keyword. (Thanks: [Matheus Rosa]). * Add support for `MYSQL_TEST_LOGIN_FILE` env variable to specify alternate login file. (Thanks: [Thomas Roten]). * Add support for `--auto-vertical-output` to automatically switch to vertical output if the output doesn't fit in the table format. * Add support for system-wide config. Now /etc/myclirc will be honored. (Thanks: [Thomas Roten]). * Add support for `nopager` and `\n` to turn off the pager. (Thanks: [Thomas Roten]). * Add support for `--local-infile` command-line option. (Thanks: [Thomas Roten]). Bug Fixes ---------- * Remove -S from `less` option which was clobbering the scroll back in history. (Thanks: [Thomas Roten]). * Make system command work with Python 3. (Thanks: [Thomas Roten]). * Support \G terminator for \f queries. (Thanks: [Terseus]). Internal Changes ----------------- * Upgrade `prompt_toolkit` to 0.60. * Add Python 3.5 to test environments. (Thanks: [Thomas Roten]). * Remove license meta-data. (Thanks: [Thomas Roten]). * Skip binary tests if PyMySQL version does not support it. (Thanks: [Thomas Roten]). * Refactor pager handling. (Thanks: [Thomas Roten]) * Capture warnings to log file. (Thanks: [Mikhail Borisov]). * Make `syntax_style` a tiny bit more intuitive. (Thanks: [Phil Cohen]). 1.5.2 ====== Bug Fixes ---------- * Protect against port number being None when no port is specified in command line. 1.5.1 ====== Bug Fixes ---------- * Cast the value of port read from my.cnf to int. 1.5.0 ====== Features --------- * Make a config option to enable `audit_log`. (Thanks: [Matheus Rosa]). * Add support for reading .mylogin.cnf to get user credentials. (Thanks: [Thomas Roten]). This feature is only available when `pycrypto` package is installed. * Register the special command `prompt` with the `\R` as alias. (Thanks: [Matheus Rosa]). Users can now change the mysql prompt at runtime using `prompt` command. eg: ``` mycli> prompt \u@\h> Changed prompt format to \u@\h> Time: 0.001s amjith@localhost> ``` * Perform completion refresh in a background thread. Now mycli can handle databases with thousands of tables without blocking. * Add support for `system` command. (Thanks: [Matheus Rosa]). Users can now run a system command from within mycli as follows: ``` amjith@localhost:(none)>system cat tmp.sql select 1; select * from django_migrations; ``` * Caught and hexed binary fields in MySQL. (Thanks: [Daniel West]). Geometric fields stored in a database will be displayed as hexed strings. * Treat enter key as tab when the suggestion menu is open. (Thanks: [Matheus Rosa]) * Add "delete" and "truncate" as destructive commands. (Thanks: [Martijn Engler]). * Change \dt syntax to add an optional table name. (Thanks: [Shoma Suzuki]). `\dt [tablename]` will describe the columns in a table. * Add TRANSACTION related keywords. * Treat DESC and EXPLAIN as DESCRIBE. (Thanks: [spacewander]). Bug Fixes ---------- * Fix the removal of whitespace from table output. * Add ability to make suggestions for compound join clauses. (Thanks: [Matheus Rosa]). * Fix the incorrect reporting of command time. * Add type validation for port argument. (Thanks [Matheus Rosa]) Internal Changes ----------------- * Make pycrypto optional and only install it in \*nix systems. (Thanks: [Irina Truong]). * Add badge for PyPI version to README. (Thanks: [Shoma Suzuki]). * Updated release script with a --dry-run and --confirm-steps option. (Thanks: [Irina Truong]). * Adds support for PyMySQL 0.6.2 and above. This is useful for debian package builders. (Thanks: [Thomas Roten]). * Disable click warning. 1.4.0 ====== Features --------- * Add `source` command. This allows running sql statement from a file. eg: ``` mycli> source filename.sql ``` * Added a config option to make the warning before destructive commands optional. (Thanks: [Daniel West](https://github.com/danieljwest)) In the config file ~/.myclirc set `destructive_warning = False` which will disable the warning before running `DROP` commands. * Add completion support for CHANGE TO and other master/slave commands. This is still preliminary and it will be enhanced in the future. * Add custom styles to color the menus and toolbars. * Upgrade `prompt_toolkit` to 0.46. (Thanks: [Jonathan Slenders]) Multi-line queries are automatically indented. Bug Fixes ---------- * Fix keyword completion after the `WHERE` clause. * Add `\g` and `\G` as valid query terminators. Previously in multi-line mode ending a query with a `\G` wouldn't run the query. This is now fixed. 1.3.0 ====== Features --------- * Add a new special command (\T) to change the table format on the fly. (Thanks: [Jonathan Bruno](https://github.com/brewneaux)) eg: ``` mycli> \T tsv ``` * Add `--defaults-group-suffix` to the command line. This lets the user specify a group to use in the my.cnf files. (Thanks: [Irina Truong](http://github.com/j-bennet)) In the my.cnf file a user can specify credentials for different databases and invoke mycli with the group name to use the appropriate credentials. eg: ``` # my.cnf [client] user = 'root' socket = '/tmp/mysql.sock' pager = 'less -RXSF' database = 'account' [clientamjith] user = 'amjith' database = 'user_management' $ mycli --defaults-group-suffix=amjith # uses the [clientamjith] section in my.cnf ``` * Add `--defaults-file` option to the command line. This allows specifying a `my.cnf` to use at launch. This also makes it play nice with mysql sandbox. * Make `-p` and `--password` take the password in commandline. This makes mycli a drop in replacement for mysql. 1.2.0 ====== Features --------- * Add support for wider completion menus in the config file. Add `wider_completion_menu = True` in the config file (~/.myclirc) to enable this feature. Bug Fixes --------- * Prevent Ctrl-C from quitting mycli while the pager is active. * Refresh auto-completions after the database is changed via a CONNECT command. Internal Changes ----------------- * Upgrade `prompt_toolkit` dependency version to 0.45. * Added Travis CI to run the tests automatically. 1.1.1 ====== Bug Fixes ---------- * Change dictonary comprehension used in mycnf reader to list comprehension to make it compatible with Python 2.6. 1.1.0 ====== Features --------- * Fuzzy completion is now case-insensitive. (Thanks: [bjarnagin](https://github.com/bjarnagin)) * Added new-line (`\n`) to the list of special characters to use in prompt. (Thanks: [brewneaux](https://github.com/brewneaux)) * Honor the `pager` setting in my.cnf files. (Thanks: [Irina Truong](http://github.com/j-bennet)) Bug Fixes ---------- * Fix a crashing bug in completion engine for cross joins. * Make `` value consistent between tabular and vertical output. Internal Changes ----------------- * Changed pymysql version to be greater than 0.6.6. * Upgrade `prompt_toolkit` version to 0.42. (Thanks: [Yasuhiro Matsumoto](https://github.com/mattn)) * Removed the explicit dependency on six. 2015/06/10 =========== Features --------- * Customizable prompt. (Thanks [Steve Robbins](https://github.com/steverobbins)) * Make `\G` formatting to behave more like mysql. Bug Fixes ---------- * Formatting issue in \G for really long column values. 2015/06/07 =========== Features --------- * Upgrade `prompt_toolkit` to 0.38. This improves the performance of pasting long queries. * Add support for reading my.cnf files. * Add editor command \e. * Replace ConfigParser with ConfigObj. * Add \dt to show all tables. * Add fuzzy completion for table names and column names. * Automatically reconnect when connection is lost to the database. Bug Fixes ---------- * Fix a bug with reconnect failure. * Fix the issue with `use` command not changing the prompt. * Fix the issue where `\\r` shortcut was not recognized. 2015/05/24 ========== Features --------- * Add support for connecting via socket. * Add completion for SQL functions. * Add completion support for SHOW statements. * Made the timing of sql statements human friendly. * Automatically prompt for a password if needed. Bug Fixes ---------- * Fixed the installation issues with PyMySQL dependency on case-sensitive file systems. [Amjith Ramanujam]: https://blog.amjith.com [Artem Bezsmertnyi]: https://github.com/mrdeathless [BuonOmo]: https://github.com/BuonOmo [Daniel West]: http://github.com/danieljwest [Dick Marinus]: https://github.com/meeuw [François Pietka]: https://github.com/fpietka [Frederic Aoustin]: https://github.com/fraoustin [Georgy Frolov]: https://github.com/pasenor [Irina Truong]: https://github.com/j-bennet [Jonathan Slenders]: https://github.com/jonathanslenders [laixintao]: https://github.com/laixintao [Martijn Engler]: https://github.com/martijnengler [Matheus Rosa]: https://github.com/mdsrosa [Mikhail Borisov]: https://github.com/borman [mtorromeo]: https://github.com/mtorromeo [mwcm]: https://github.com/mwcm [Phil Cohen]: https://github.com/phlipper [Scrappy Soft]: https://github.com/scrappysoft [Shoma Suzuki]: https://github.com/shoma [spacewander]: https://github.com/spacewander [Terseus]: https://github.com/Terseus [Thomas Roten]: https://github.com/tsroten [xeron]: https://github.com/xeron [Zach DeCook]: https://zachdecook.com [Will Wang]: https://github.com/willww64 ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1762004092.2818172 mycli-1.41.0/doc/0000755000175100017510000000000015101406174013124 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/doc/key_bindings.rst0000644000175100017510000000311115101406164016316 0ustar00runnerrunner************* Key Bindings: ************* Most key bindings are simply inherited from `prompt-toolkit `_ . 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. ################## C-o d (Emacs-mode) ################## Insert the current date at cursor, defined by NOW() on the server. #################### C-o C-d (Emacs-mode) #################### Insert the quoted current date at cursor. ################## C-o t (Emacs-mode) ################## Insert the current datetime at cursor. #################### C-o C-t (Emacs-mode) #################### Insert the quoted current datetime at cursor. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/doc/llm.md0000644000175100017510000001250515101406164014234 0ustar00runnerrunner# Using the \llm Command (AI-assisted SQL) The `\llm` special command lets you ask natural-language questions and get SQL proposed for you. It uses the open‑source `llm` CLI under the hood and enriches your prompt with database context (schema and one sample row per table) so answers can include runnable SQL. Alias: `\ai` works the same as `\llm`. --- ## Quick Start 1) Make sure mycli is installed with the `[llm]` extras, like ```bash pip install 'mycli[llm]' ``` or that the `llm` dependency is installed separately: ```bash pip install llm ``` 2) From the mycli prompt, configure your API key (only needed for remote providers like OpenAI): ```text \llm keys set openai ``` 3) Ask a question. The response’s SQL (inside a ```sql fenced block) is extracted and pre-filled at the prompt: ```text World> \llm "Capital of India?" -- Answer text from the model... -- ```sql -- SELECT ...; -- ``` -- Your prompt is prefilled with the SQL above. ``` You can now hit Enter to run, or edit the query first. --- ## What Context Is Sent When you ask a plain question via `\llm "..."`, mycli: - Sends your question. - Adds your current database schema: table names with column types. - Adds one sample row (if available) from each table. This helps the model propose SQL that fits your schema. Follow‑ups using `-c` continue the same conversation and do not re-send the DB context (see “Continue Conversation (-c)”). Note: Context is gathered from the current connection. If you are not connected, using contextual mode will fail — connect first. --- ## Using `llm` Subcommands from mycli You can run any `llm` CLI subcommand by prefixing it with `\llm` inside mycli. Examples: - List models: ```text \llm models ``` - Set the default model: ```text \llm models default gpt-5 ``` - Set provider API key: ```text \llm keys set openai ``` - Install a plugin (e.g., local models via Ollama): ```text \llm install llm-ollama ``` After installing or uninstalling plugins, mycli will restart to pick up new commands. Tab completion works for `\llm` subcommands, and even for model IDs under `models default`. Aside: for using local models. --- ## Ask Questions With DB Context (default) Ask your question in quotes. mycli sends database context and extracts a SQL block if present. ```text World> \llm "Most visited urls?" ``` Behavior: - Response is printed in the output pane. - If the response contains a ```sql fenced block, mycli extracts the SQL and pre-fills it at your prompt. --- ## Continue Conversation (-c) Use `-c` to ask a follow‑up that continues the previous conversation with the model. This does not re-send the DB context; it relies on the ongoing thread. ```text World> \llm "Top 10 customers by spend" -- model returns analysis and a ```sql block; SQL is prefilled World> \llm -c "Now include each customer's email and order count" ``` Behavior: - Continues the last conversation in the `llm` history. - Database context is not re-sent on follow‑ups. - If the response includes a ```sql block, the SQL is pre-filled at your prompt. --- ## Examples - List available models: ```text World> \llm models ``` - Change default model: ```text World> \llm models default llama3 ``` - Set API key (for providers that require it): ```text World> \llm keys set openai ``` - Ask a question with context: ```text World> \llm "Capital of India?" ``` - Use a local model (after installing a plugin such as `llm-ollama`): ```text World> \llm install llm-ollama World> \llm models default llama3 World> \llm "Top 10 customers by spend" ``` See: for details. --- ## Customize the Prompt Template mycli uses a saved `llm` template named `mycli-llm-template` for contextual questions. You can view or edit it: ```text World> \llm templates edit mycli-llm-template ``` Tip: After first use, mycli ensures this template exists. To just view it without editing, use: ```text World> \llm templates show mycli-llm-template ``` --- ## Troubleshooting - No SQL pre-fill: Ensure the model’s response includes a ```sql fenced block. The built‑in prompt encourages this, but some models may omit it; try asking the model to include SQL in a ```sql block. - Not connected to a database: Contextual questions require a live connection. Connect first. Follow‑ups with `-c` only help after a successful contextual call. - Plugin changes not recognized: After `\llm install` or `\llm uninstall`, mycli restarts automatically to load new commands. - Provider/API issues: Use `\llm keys list` and `\llm keys set ` to check credentials. Use `\llm models` to confirm available models. --- ## Notes and Safety - Data sent: Contextual questions send schema (table/column names and types) and a single sample row per table. Review your data sensitivity policies before using remote models; prefer local models (such as ollama) if needed. - Help: Running `\llm` with no arguments shows a short usage message. ## Turning Off LLM Support To turn off LLM support even when the `llm` dependency is installed, set the `MYCLI_LLM_OFF` environment variable: ```bash export MYCLI_LLM_OFF=1 ``` This may be desirable for faster startup times. --- ## Learn More - `llm` project docs: https://llm.datasette.io/ - `llm` plugin directory: https://llm.datasette.io/en/stable/plugins/directory.html ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1762004092.2848172 mycli-1.41.0/mycli/0000755000175100017510000000000015101406174013474 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/AUTHORS0000644000175100017510000000354415101406164014551 0ustar00runnerrunnerProject Lead: ------------- * Roland Walker Core Developers: ---------------- * Thomas Roten * Irina Truong * Matheus Rosa * Darik Gamble * Dick Marinus * Amjith Ramanujam Contributors: ------------- * 0xflotus * Abirami P * Adam Chainz * Aljosha Papsch * Allrob * 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 * FatBoyXPC * 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 * Miodrag Tokić * 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 * Sherlock Holo * keltaklo * 924060929 Created by: ----------- Amjith Ramanujam ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/SPONSORS0000644000175100017510000000074415101406164014711 0ustar00runnerrunnerMany 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 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/__init__.py0000644000175100017510000000012215101406164015577 0ustar00runnerrunnerimport importlib.metadata __version__: str = importlib.metadata.version("mycli") ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/clibuffer.py0000644000175100017510000000302415101406164016005 0ustar00runnerrunnerfrom prompt_toolkit.application import get_app from prompt_toolkit.enums import DEFAULT_BUFFER from prompt_toolkit.filters import Condition, Filter from mycli.packages.special import iocommands def cli_is_multiline(mycli) -> Filter: @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: str) -> bool: 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(( iocommands.get_current_delimiter(), "\\g", "\\G", r"\e", 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 == "") ) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/clistyle.py0000644000175100017510000001467315101406164015710 0ustar00runnerrunnerimport logging from prompt_toolkit.styles import Style, merge_styles from prompt_toolkit.styles.pygments import style_from_pygments_cls from prompt_toolkit.styles.style import _MergedStyle from pygments.style import Style as PygmentsStyle import pygments.styles from pygments.token import Token, string_to_tokentype from pygments.util import ClassNotFound logger = logging.getLogger(__name__) # map Pygments tokens (ptk 1.0) to class names (ptk 2.0). TOKEN_TO_PROMPT_STYLE: dict[Token, str] = { 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: dict[str, 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: dict[str, 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: str, style_object: PygmentsStyle | str, style_dict: dict[str, str], ) -> tuple[Token, str]: """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) if isinstance(style_object, PygmentsStyle): # When a Pygments Style class is passed, use its "styles" mapping. other_token_type = string_to_tokentype(style_dict[token_name]) return token_type, style_object.styles[other_token_type] else: return token_type, style_dict[token_name] def style_factory(name: str, cli_style: dict[str, str]) -> _MergedStyle: try: style: PygmentsStyle = pygments.styles.get_style_by_name(name) except ClassNotFound: style = pygments.styles.get_style_by_name("native") prompt_styles: list[tuple[str, str]] = [] # 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 = Style([("bottom-toolbar", "noreverse")]) return merge_styles([style_from_pygments_cls(style), override_style, Style(prompt_styles)]) def style_factory_output(name: str, cli_style: dict[str, str]) -> PygmentsStyle: try: style: dict[PygmentsStyle | str, str] = 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 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/clitoolbar.py0000644000175100017510000000353615101406164016206 0ustar00runnerrunnerfrom typing import Callable from prompt_toolkit.application import get_app from prompt_toolkit.enums import EditingMode from prompt_toolkit.key_binding.vi_state import InputMode from mycli.packages import special def create_toolbar_tokens_func(mycli, show_fish_help: Callable) -> Callable: """Return a function that generates the toolbar tokens.""" def get_toolbar_tokens() -> list[tuple[str, str]]: result = [("class:bottom-toolbar", " ")] if mycli.multi_line: delimiter = special.get_current_delimiter() result.append(( "class:bottom-toolbar", f' ({"Semi-colon" if delimiter == ";" else "Delimiter"} [{delimiter}] will end the line) ', )) 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", f"Vi-mode ({_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() -> str: """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] ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/compat.py0000644000175100017510000000016615101406164015333 0ustar00runnerrunner"""Platform and Python version compatibility support.""" import sys WIN: bool = sys.platform in ("win32", "cygwin") ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/completion_refresher.py0000644000175100017510000001320215101406164020261 0ustar00runnerrunnerimport threading from typing import Callable from mycli.packages.special.main import COMMANDS from mycli.sqlcompleter import SQLCompleter from mycli.sqlexecute import ServerSpecies, SQLExecute class CompletionRefresher: refreshers: dict = {} def __init__(self) -> None: self._completer_thread: threading.Thread | None = None self._restart_refresh = threading.Event() def refresh( self, executor: SQLExecute, callbacks: Callable | list[Callable], completer_options: dict | None = None, ) -> list[tuple]: """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) -> bool: return bool(self._completer_thread and self._completer_thread.is_alive()) def _bg_refresh( self, sqlexecute: SQLExecute, callbacks: Callable | list[Callable], completer_options: dict, ) -> None: completer = SQLCompleter(**completer_options) # Create a new sqlexecute 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: str, refreshers: dict = CompletionRefresher.refreshers) -> Callable: """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: SQLCompleter, executor: SQLExecute) -> None: completer.extend_database_names(executor.databases()) @refresher("schemata") def refresh_schemata(completer: SQLCompleter, executor: SQLExecute) -> None: # 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: SQLCompleter, executor: SQLExecute) -> None: 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: SQLCompleter, executor: SQLExecute) -> None: completer.extend_users(executor.users()) # @refresher('views') # def refresh_views(completer: SQLCompleter, executor: SQLExecute) -> None: # completer.extend_relations(executor.views(), kind='views') # completer.extend_columns(executor.view_columns(), kind='views') @refresher("functions") def refresh_functions(completer: SQLCompleter, executor: SQLExecute) -> None: completer.extend_functions(executor.functions()) if executor.server_info and executor.server_info.species == ServerSpecies.TiDB: completer.extend_functions(completer.tidb_functions, builtin=True) @refresher("special_commands") def refresh_special(completer: SQLCompleter, executor: SQLExecute) -> None: completer.extend_special_commands(list(COMMANDS.keys())) @refresher("show_commands") def refresh_show_commands(completer: SQLCompleter, executor: SQLExecute) -> None: completer.extend_show_items(executor.show_candidates()) @refresher("keywords") def refresh_keywords(completer: SQLCompleter, executor: SQLExecute) -> None: if executor.server_info and executor.server_info.species == ServerSpecies.TiDB: completer.extend_keywords(completer.tidb_keywords, replace=True) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/config.py0000644000175100017510000002413115101406164015313 0ustar00runnerrunnerfrom copy import copy from importlib import resources from io import BytesIO, TextIOWrapper import logging import os from os.path import exists import struct import sys from typing import IO, BinaryIO, Literal, TextIO from configobj import ConfigObj, ConfigObjError from Cryptodome.Cipher import AES logger = logging.getLogger(__name__) def log(logger: logging.Logger, level: int, message: str) -> None: """Logs message to stderr if logging isn't initialized.""" if logger.parent and logger.parent.name == "root": print(message, file=sys.stderr) logger.log(level, message) def read_config_file(f: str | TextIO | TextIOWrapper, list_values: bool = True) -> ConfigObj | None: """Read a config file. *list_values* set to `True` is the default behavior of ConfigObj. Disabling it causes values to not be parsed for lists, (e.g. 'a,b,c' -> ['a', 'b', 'c']. Additionally, the config values are not unquoted. We are disabling list_values when reading MySQL config files so we can correctly interpret commas in passwords. """ if isinstance(f, str): f = os.path.expanduser(f) try: config = ConfigObj(f, interpolation=False, encoding="utf8", list_values=list_values) except ConfigObjError as e: log(logger, logging.WARNING, "Unable to parse line {0} of config file '{1}'.".format(e.line_number, f)) log(logger, logging.WARNING, "Using successfully parsed config values.") return e.config except (IOError, OSError) as e: log(logger, logging.WARNING, "You don't have permission to read config file '{0}'.".format(e.filename)) return None return config def get_included_configs(config_file: str | TextIOWrapper) -> list[str | TextIOWrapper]: """Get a list of configuration files that are included into config_path with !includedir directive. "Normal" configs should be passed as file paths. The only exception is .mylogin which is decoded into a stream. However, it never contains include directives and so will be ignored by this function. """ if not isinstance(config_file, str) or not os.path.isfile(config_file): return [] included_configs: list[str | TextIOWrapper] = [] try: with open(config_file) as f: include_directives = filter(lambda s: s.startswith("!includedir"), f) dirs_split = (s.strip().split()[-1] for s in include_directives) dirs = filter(os.path.isdir, dirs_split) for dir_ in dirs: for filename in os.listdir(dir_): if filename.endswith(".cnf"): included_configs.append(os.path.join(dir_, filename)) except (PermissionError, UnicodeDecodeError): pass return included_configs def read_config_files(files: list[str | TextIOWrapper], list_values: bool = True) -> ConfigObj: """Read and merge a list of config files.""" config = create_default_config(list_values=list_values) _files = copy(files) while _files: _file = _files.pop(0) _config = read_config_file(_file, list_values=list_values) # expand includes only if we were able to parse config # (otherwise we'll just encounter the same errors again) if config is not None: _files = get_included_configs(_file) + _files if _config is not None: config.merge(_config) config.filename = _config.filename return config def create_default_config(list_values: bool = True) -> ConfigObj: import mycli default_config_file = resources.open_text(mycli, "myclirc") return read_config_file(default_config_file, list_values=list_values) def write_default_config(destination: str, overwrite: bool = False) -> None: import mycli default_config = resources.read_text(mycli, "myclirc") destination = os.path.expanduser(destination) if not overwrite and exists(destination): return with open(destination, "w") as f: f.write(default_config) def get_mylogin_cnf_path() -> str | None: """Return the path to the login path file or None if it doesn't exist.""" mylogin_cnf_path = os.getenv("MYSQL_TEST_LOGIN_FILE") if mylogin_cnf_path is None: app_data = os.getenv("APPDATA") default_dir = os.path.join(app_data, "MySQL") if app_data else "~" mylogin_cnf_path = os.path.join(default_dir, ".mylogin.cnf") mylogin_cnf_path = os.path.expanduser(mylogin_cnf_path) if exists(mylogin_cnf_path): logger.debug("Found login path file at '{0}'".format(mylogin_cnf_path)) return mylogin_cnf_path return None def open_mylogin_cnf(name: str) -> TextIOWrapper | None: """Open a readable version of .mylogin.cnf. Returns the file contents as a TextIOWrapper object. :param str name: The pathname of the file to be opened. :return: the login path file or None """ try: with open(name, "rb") as f: plaintext = read_and_decrypt_mylogin_cnf(f) except (OSError, IOError, ValueError): logger.error("Unable to open login path file.") return None if not isinstance(plaintext, BytesIO): logger.error("Unable to read login path file.") return None return TextIOWrapper(plaintext) # TODO reuse code between encryption an decryption def encrypt_mylogin_cnf(plaintext: IO[str]) -> BytesIO: """Encryption of .mylogin.cnf file, analogous to calling mysql_config_editor. Code is based on the python implementation by Kristian Koehntopp https://github.com/isotopp/mysql-config-coder """ def realkey(key: bytes) -> bytes: """Create the AES key from the login key.""" rkey = bytearray(16) for i in range(len(key)): rkey[i % 16] ^= key[i] return bytes(rkey) def encode_line(plaintext: str, real_key: bytes, buf_len: int) -> bytes: aes = AES.new(real_key, AES.MODE_ECB) text_len = len(plaintext) pad_len = buf_len - text_len pad_chr = bytes(chr(pad_len), "utf8") plaintext_b = plaintext.encode() + pad_chr * pad_len encrypted_text = b"".join([aes.encrypt(plaintext_b[i : i + 16]) for i in range(0, len(plaintext_b), 16)]) return encrypted_text LOGIN_KEY_LENGTH = 20 key = os.urandom(LOGIN_KEY_LENGTH) real_key = realkey(key) outfile = BytesIO() outfile.write(struct.pack("i", 0)) outfile.write(key) while True: line = plaintext.readline() if not line: break real_len = len(line) pad_len = (int(real_len / 16) + 1) * 16 outfile.write(struct.pack("i", pad_len)) x = encode_line(line, real_key, pad_len) outfile.write(x) outfile.seek(0) return outfile def read_and_decrypt_mylogin_cnf(f: BinaryIO) -> BytesIO | None: """Read and decrypt the contents of .mylogin.cnf. This decryption algorithm mimics the code in MySQL's mysql_config_editor.cc. The login key is 20-bytes of random non-printable ASCII. It is written to the actual login path file. It is used to generate the real key used in the AES cipher. :param f: an I/O object opened in binary mode :return: the decrypted login path file :rtype: io.BytesIO or None """ # Number of bytes used to store the length of ciphertext. MAX_CIPHER_STORE_LEN = 4 LOGIN_KEY_LEN = 20 # Move past the unused buffer. buf = f.read(4) if not buf or len(buf) != 4: logger.error("Login path file is blank or incomplete.") return None # Read the login key. key = f.read(LOGIN_KEY_LEN) # Generate the real key. rkey = [0] * 16 for i in range(LOGIN_KEY_LEN): try: rkey[i % 16] ^= ord(key[i : i + 1]) except TypeError: # ord() was unable to get the value of the byte. logger.error("Unable to generate login path AES key.") return None rkey_b = struct.pack("16B", *rkey) # Create a bytes buffer to hold the plaintext. plaintext = BytesIO() aes = AES.new(rkey_b, AES.MODE_ECB) while True: # Read the length of the ciphertext. len_buf = f.read(MAX_CIPHER_STORE_LEN) if len(len_buf) < MAX_CIPHER_STORE_LEN: break (cipher_len,) = struct.unpack(" bool: """Convert a string value to its corresponding boolean value.""" if isinstance(s, bool): return s elif not isinstance(s, str): raise TypeError("argument must be a string") true_values = ("true", "on", "1") false_values = ("false", "off", "0") if s.lower() in true_values: return True elif s.lower() in false_values: return False else: raise ValueError(f'not a recognized boolean value: {s}') def strip_matching_quotes(s: str) -> str: """Remove matching, surrounding quotes from a string. This is the same logic that ConfigObj uses when parsing config values. """ if isinstance(s, str) and len(s) >= 2 and s[0] == s[-1] and s[0] in ('"', "'"): s = s[1:-1] return s def _remove_pad(line: bytes) -> bytes | Literal[False]: """Remove the pad from the *line*.""" try: # Determine pad length. pad_length = ord(line[-1:]) except TypeError: # ord() was unable to get the value of the byte. logger.warning("Unable to remove pad.") return False if pad_length > len(line) or len(set(line[-pad_length:])) != 1: # Pad length should be less than or equal to the length of the # plaintext. The pad should have a single unique byte. logger.warning("Invalid pad found in login path file.") return False return line[:-pad_length] ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/key_bindings.py0000644000175100017510000001457315101406164016524 0ustar00runnerrunnerimport logging from prompt_toolkit.enums import EditingMode from prompt_toolkit.filters import completion_is_selected, control_is_searchable, emacs_mode from prompt_toolkit.key_binding import KeyBindings from prompt_toolkit.key_binding.key_processor import KeyPressEvent from mycli.packages import shortcuts from mycli.packages.toolkit.fzf import search_history _logger = logging.getLogger(__name__) def mycli_bindings(mycli) -> KeyBindings: """Custom key bindings for mycli.""" kb = KeyBindings() @kb.add("f2") def _(_event: KeyPressEvent) -> None: """Enable/Disable SmartCompletion Mode.""" _logger.debug("Detected F2 key.") mycli.completer.smart_completion = not mycli.completer.smart_completion @kb.add("f3") def _(_event: KeyPressEvent) -> None: """Enable/Disable Multiline Mode.""" _logger.debug("Detected F3 key.") mycli.multi_line = not mycli.multi_line @kb.add("f4") def _(event: KeyPressEvent) -> None: """Toggle between Vi and Emacs mode.""" _logger.debug("Detected F4 key.") if mycli.key_bindings == "vi": event.app.editing_mode = EditingMode.EMACS mycli.key_bindings = "emacs" else: event.app.editing_mode = EditingMode.VI mycli.key_bindings = "vi" @kb.add("tab") def _(event: KeyPressEvent) -> None: """Force autocompletion at cursor.""" _logger.debug("Detected key.") b = event.app.current_buffer if b.complete_state: b.complete_next() else: b.start_completion(select_first=True) @kb.add("c-space") def _(event: KeyPressEvent) -> None: """ 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. """ _logger.debug("Detected key.") b = event.app.current_buffer if b.complete_state: b.complete_next() else: b.start_completion(select_first=False) @kb.add("c-x", "p", filter=emacs_mode) def _(event: KeyPressEvent) -> None: """ Prettify and indent current statement, usually into multiple lines. Only accepts buffers containing single SQL statements. """ _logger.debug("Detected /> key.") b = event.app.current_buffer cursorpos_relative = b.cursor_position / max(1, len(b.text)) pretty_text = mycli.handle_prettify_binding(b.text) if len(pretty_text) > 0: b.text = pretty_text cursorpos_abs = int(round(cursorpos_relative * len(b.text))) while 0 < cursorpos_abs < len(b.text) and b.text[cursorpos_abs] in (" ", "\n"): cursorpos_abs -= 1 b.cursor_position = min(cursorpos_abs, len(b.text)) @kb.add("c-x", "u", filter=emacs_mode) def _(event: KeyPressEvent) -> None: """ Unprettify and dedent current statement, usually into one line. Only accepts buffers containing single SQL statements. """ _logger.debug("Detected /< key.") b = event.app.current_buffer cursorpos_relative = b.cursor_position / max(1, len(b.text)) unpretty_text = mycli.handle_unprettify_binding(b.text) if len(unpretty_text) > 0: b.text = unpretty_text cursorpos_abs = int(round(cursorpos_relative * len(b.text))) while 0 < cursorpos_abs < len(b.text) and b.text[cursorpos_abs] in (" ", "\n"): cursorpos_abs -= 1 b.cursor_position = min(cursorpos_abs, len(b.text)) @kb.add("c-o", "d", filter=emacs_mode) def _(event: KeyPressEvent) -> None: """ Insert the current date. """ _logger.debug("Detected key.") event.app.current_buffer.insert_text(shortcuts.server_date(mycli.sqlexecute)) @kb.add("c-o", "c-d", filter=emacs_mode) def _(event: KeyPressEvent) -> None: """ Insert the quoted current date. """ _logger.debug("Detected key.") event.app.current_buffer.insert_text(shortcuts.server_date(mycli.sqlexecute, quoted=True)) @kb.add("c-o", "t", filter=emacs_mode) def _(event: KeyPressEvent) -> None: """ Insert the current datetime. """ _logger.debug("Detected key.") event.app.current_buffer.insert_text(shortcuts.server_datetime(mycli.sqlexecute)) @kb.add("c-o", "c-t", filter=emacs_mode) def _(event: KeyPressEvent) -> None: """ Insert the quoted current datetime. """ _logger.debug("Detected key.") event.app.current_buffer.insert_text(shortcuts.server_datetime(mycli.sqlexecute, quoted=True)) @kb.add("c-r", filter=control_is_searchable) def _(event: KeyPressEvent) -> None: """Search history using fzf or reverse incremental search.""" _logger.debug("Detected key.") mode = mycli.config.get('keys', {}).get('control_r', 'auto') if mode == 'reverse_isearch': search_history(event, incremental=True) else: search_history(event) @kb.add("escape", "r", filter=control_is_searchable & emacs_mode) def _(event: KeyPressEvent) -> None: """Search history using fzf when available.""" _logger.debug("Detected key.") search_history(event) @kb.add("enter", filter=completion_is_selected) def _(event: KeyPressEvent) -> None: """Makes the enter key work as the tab key only when showing the menu. In other words, don't execute query when enter is pressed in the completion dropdown menu, instead close the dropdown menu (accept current selection). """ _logger.debug("Detected enter key.") event.current_buffer.complete_state = None b = event.app.current_buffer b.complete_state = None @kb.add("escape", "enter") def _(event: KeyPressEvent) -> None: """Introduces a line break in multi-line mode, or dispatches the command in single-line mode.""" _logger.debug("Detected alt-enter key.") if mycli.multi_line: event.app.current_buffer.validate_and_handle() else: event.app.current_buffer.insert_text("\n") return kb ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/lexer.py0000644000175100017510000000044515101406164015167 0ustar00runnerrunnerfrom pygments.lexer import inherit from pygments.lexers.sql import MySqlLexer from pygments.token import Keyword class MyCliLexer(MySqlLexer): """Extends MySQL lexer to add keywords.""" tokens = { "root": [(r"\brepair\b", Keyword), (r"\boffset\b", Keyword), inherit], } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/magic.py0000644000175100017510000000416115101406164015127 0ustar00runnerrunnerimport logging from typing import Any import sql.connection import sql.parse from mycli.main import MyCli, Query _logger: logging.Logger = logging.getLogger(__name__) def load_ipython_extension(ipython) -> None: # This is called via the ipython command '%load_ext mycli.magic'. # First, load the sql magic if it isn't already loaded. if not ipython.find_line_magic("sql"): ipython.run_line_magic("load_ext", "sql") # Register our own magic. ipython.register_magic_function(mycli_line_magic, "line", "mycli") def mycli_line_magic(line: str): _logger.debug("mycli magic called: %r", line) parsed: dict[str, Any] = sql.parse.parse(line, {}) # "get" was renamed to "set" in ipython-sql: # https://github.com/catherinedevlin/ipython-sql/commit/f4283c65aaf68f961e84019e8b939e4a3c501d43 if hasattr(sql.connection.Connection, "get"): conn = sql.connection.Connection.get(parsed["connection"]) else: try: conn = sql.connection.Connection.set(parsed["connection"]) # a new positional argument was added to Connection.set in version 0.4.0 of ipython-sql except TypeError: conn = sql.connection.Connection.set(parsed["connection"], False) try: # A corresponding mycli object already exists mycli: MyCli = conn._mycli _logger.debug("Reusing existing mycli") except AttributeError: mycli = MyCli() u = conn.session.engine.url _logger.debug("New mycli: %r", str(u)) mycli.connect(host=u.host, port=u.port, passwd=u.password, database=u.database, user=u.username, init_command=None) conn._mycli = mycli # For convenience, print the connection alias print(f'Connected: {conn.name}') try: mycli.run_cli() except SystemExit: pass if not mycli.query_history: return q: Query = mycli.query_history[-1] if q.mutating: _logger.debug("Mutating query detected -- ignoring") return if q.successful: ipython = get_ipython() # type: ignore # noqa: F821 return ipython.run_cell_magic("sql", line, q.query) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/main.py0000755000175100017510000020572015101406164015002 0ustar00runnerrunnerfrom __future__ import annotations from collections import defaultdict, namedtuple from io import TextIOWrapper import logging import os import re import shutil import sys import threading import traceback from typing import Any, Generator, Iterable, Literal try: from pwd import getpwuid except ImportError: pass from datetime import datetime from importlib import resources import itertools from random import choice from time import time from urllib.parse import parse_qs, unquote, urlparse from cli_helpers.tabular_output import TabularOutputFormatter, preprocessors from cli_helpers.utils import strip_ansi import click from configobj import ConfigObj from prompt_toolkit.auto_suggest import AutoSuggestFromHistory from prompt_toolkit.completion import Completion, DynamicCompleter from prompt_toolkit.document import Document from prompt_toolkit.enums import DEFAULT_BUFFER, EditingMode from prompt_toolkit.filters import HasFocus, IsDone from prompt_toolkit.formatted_text import ANSI, AnyFormattedText from prompt_toolkit.key_binding.bindings.named_commands import register as prompt_register from prompt_toolkit.key_binding.key_processor import KeyPressEvent from prompt_toolkit.layout.processors import ConditionalProcessor, HighlightMatchingBracketProcessor from prompt_toolkit.lexers import PygmentsLexer from prompt_toolkit.shortcuts import CompleteStyle, PromptSession from pymysql import OperationalError, err from pymysql.cursors import Cursor import sqlglot import sqlparse from mycli import __version__ from mycli.clibuffer import cli_is_multiline from mycli.clistyle import style_factory, style_factory_output from mycli.clitoolbar import create_toolbar_tokens_func from mycli.compat import WIN from mycli.completion_refresher import CompletionRefresher from mycli.config import get_mylogin_cnf_path, open_mylogin_cnf, read_config_files, str_to_bool, strip_matching_quotes, write_default_config from mycli.key_bindings import mycli_bindings from mycli.lexer import MyCliLexer from mycli.packages import special from mycli.packages.filepaths import dir_path_exists, guess_socket_location from mycli.packages.hybrid_redirection import get_redirect_components, is_redirect_command from mycli.packages.parseutils import is_destructive, is_dropping_database from mycli.packages.prompt_utils import confirm, confirm_destructive_query from mycli.packages.special.favoritequeries import FavoriteQueries from mycli.packages.special.main import ArgType from mycli.packages.tabular_output import sql_format from mycli.packages.toolkit.history import FileHistoryWithTimestamp from mycli.sqlcompleter import SQLCompleter from mycli.sqlexecute import ERROR_CODE_ACCESS_DENIED, FIELD_TYPES, SQLExecute try: import paramiko except ImportError: from mycli.packages.paramiko_stub import paramiko # type: ignore[no-redef] # Query tuples are used for maintaining history Query = namedtuple("Query", ["query", "successful", "mutating"]) SUPPORT_INFO = "Home: http://mycli.net\nBug tracker: https://github.com/dbcli/mycli/issues" DEFAULT_WIDTH = 80 DEFAULT_HEIGHT = 25 class MyCli: default_prompt = "\\t \\u@\\h:\\d> " default_prompt_splitln = "\\u@\\h\\n(\\t):\\d>" max_len_prompt = 45 defaults_suffix = None # In order of being loaded. Files lower in list override earlier ones. cnf_files: list[str | TextIOWrapper] = [ "/etc/my.cnf", "/etc/mysql/my.cnf", "/usr/local/etc/my.cnf", os.path.expanduser("~/.my.cnf"), ] # check XDG_CONFIG_HOME exists and not an empty string xdg_config_home = os.environ.get("XDG_CONFIG_HOME", "~/.config") system_config_files: list[str | TextIOWrapper] = [ "/etc/myclirc", os.path.join(os.path.expanduser(xdg_config_home), "mycli", "myclirc"), ] pwd_config_file = os.path.join(os.getcwd(), ".myclirc") def __init__( self, sqlexecute: SQLExecute | None = None, prompt: str | None = None, logfile: TextIOWrapper | Literal[False] | None = None, defaults_suffix: str | None = None, defaults_file: str | None = None, login_path: str | None = None, auto_vertical_output: bool = False, warn: bool | None = None, myclirc: str = "~/.myclirc", ) -> None: self.sqlexecute = sqlexecute self.logfile = logfile self.defaults_suffix = defaults_suffix self.login_path = login_path self.toolbar_error_message: str | None = None self.prompt_app: PromptSession | None = None # self.cnf_files is a class variable that stores the list of mysql # config files to read in at launch. # If defaults_file is specified then override the class variable with # defaults_file. if defaults_file: self.cnf_files = [defaults_file] # Load config. config_files: list[str | TextIOWrapper] = self.system_config_files + [myclirc] + [self.pwd_config_file] c = self.config = read_config_files(config_files) self.multi_line = c["main"].as_bool("multi_line") self.key_bindings = c["main"]["key_bindings"] special.set_timing_enabled(c["main"].as_bool("timing")) self.beep_after_seconds = float(c["main"]["beep_after_seconds"] or 0) FavoriteQueries.instance = FavoriteQueries.from_config(self.config) self.dsn_alias: str | None = None self.main_formatter = TabularOutputFormatter(format_name=c["main"]["table_format"]) self.redirect_formatter = TabularOutputFormatter(format_name=c["main"].get("redirect_format", "csv")) sql_format.register_new_formatter(self.main_formatter) sql_format.register_new_formatter(self.redirect_formatter) self.main_formatter.mycli = self self.redirect_formatter.mycli = self self.syntax_style = c["main"]["syntax_style"] self.less_chatty = c["main"].as_bool("less_chatty") self.cli_style = c["colors"] self.output_style = style_factory_output(self.syntax_style, self.cli_style) self.wider_completion_menu = c["main"].as_bool("wider_completion_menu") c_dest_warning = c["main"].as_bool("destructive_warning") self.destructive_warning = c_dest_warning if warn is None else warn self.login_path_as_host = c["main"].as_bool("login_path_as_host") self.post_redirect_command = c['main'].get('post_redirect_command') # read from cli argument or user config file self.auto_vertical_output = auto_vertical_output or c["main"].as_bool("auto_vertical_output") # Write user config if system config wasn't the last config loaded. if c.filename not in self.system_config_files and not os.path.exists(myclirc): write_default_config(myclirc) # audit log if self.logfile is None and "audit_log" in c["main"]: try: self.logfile = open(os.path.expanduser(c["main"]["audit_log"]), "a") except (IOError, OSError): self.echo("Error: Unable to open the audit log file. Your queries will not be logged.", err=True, fg="red") self.logfile = False self.completion_refresher = CompletionRefresher() self.logger = logging.getLogger(__name__) self.initialize_logging() keyword_casing = c["main"].get("keyword_casing", "auto") self.query_history: list[Query] = [] # Initialize completer. self.smart_completion = c["main"].as_bool("smart_completion") self.completer = SQLCompleter( self.smart_completion, supported_formats=self.main_formatter.supported_formats, keyword_casing=keyword_casing ) self._completer_lock = threading.Lock() # Register custom special commands. self.register_special_commands() # Load .mylogin.cnf if it exists. mylogin_cnf_path = get_mylogin_cnf_path() if mylogin_cnf_path: mylogin_cnf = open_mylogin_cnf(mylogin_cnf_path) if mylogin_cnf_path and mylogin_cnf: # .mylogin.cnf gets read last, even if defaults_file is specified. self.cnf_files.append(mylogin_cnf) elif mylogin_cnf_path and not mylogin_cnf: # There was an error reading the login path file. print("Error: Unable to read login path file.") self.my_cnf = read_config_files(self.cnf_files, list_values=False) prompt_cnf = self.read_my_cnf(self.my_cnf, ["prompt"])["prompt"] self.prompt_format = prompt or prompt_cnf or c["main"]["prompt"] or self.default_prompt self.multiline_continuation_char = c["main"]["prompt_continuation"] self.prompt_app = None def register_special_commands(self) -> None: special.register_special_command(self.change_db, "use", "\\u", "Change to a new database.", aliases=["\\u"]) special.register_special_command( self.change_db, "connect", "\\r", "Reconnect to the database. Optional database argument.", aliases=["\\r"], case_sensitive=True, ) special.register_special_command( self.refresh_completions, "rehash", "\\#", "Refresh auto-completions.", arg_type=ArgType.NO_QUERY, aliases=["\\#"] ) special.register_special_command( self.change_table_format, "tableformat", "\\T", "Change the table format used to output results.", aliases=["\\T"], case_sensitive=True, ) special.register_special_command( self.change_redirect_format, "redirectformat", "\\Tr", "Change the table format used to output redirected results.", aliases=["\\Tr"], case_sensitive=True, ) special.register_special_command(self.execute_from_file, "source", "\\. filename", "Execute commands from file.", aliases=["\\."]) special.register_special_command( self.change_prompt_format, "prompt", "\\R", "Change prompt format.", aliases=["\\R"], case_sensitive=True ) def change_table_format(self, arg: str, **_) -> Generator[tuple, None, None]: try: self.main_formatter.format_name = arg yield (None, None, None, f"Changed table format to {arg}") except ValueError: msg = f"Table format {arg} not recognized. Allowed formats:" for table_type in self.main_formatter.supported_formats: msg += f"\n\t{table_type}" yield (None, None, None, msg) def change_redirect_format(self, arg: str, **_) -> Generator[tuple, None, None]: try: self.redirect_formatter.format_name = arg yield (None, None, None, f"Changed redirect format to {arg}") except ValueError: msg = f"Redirect format {arg} not recognized. Allowed formats:" for table_type in self.redirect_formatter.supported_formats: msg += f"\n\t{table_type}" yield (None, None, None, msg) def change_db(self, arg: str, **_) -> Generator[tuple, None, None]: if arg.startswith("`") and arg.endswith("`"): arg = re.sub(r"^`(.*)`$", r"\1", arg) arg = re.sub(r"``", r"`", arg) if not arg: click.secho("No database selected", err=True, fg="red") return assert isinstance(self.sqlexecute, SQLExecute) self.sqlexecute.change_db(arg) yield ( None, None, None, f'You are now connected to database "{self.sqlexecute.dbname}" as user "{self.sqlexecute.user}"', ) def execute_from_file(self, arg: str, **_) -> Iterable[tuple]: if not arg: message = "Missing required argument: filename." return [(None, None, None, message)] try: with open(os.path.expanduser(arg)) as f: query = f.read() except IOError as e: return [(None, None, None, str(e))] if self.destructive_warning and confirm_destructive_query(query) is False: message = "Wise choice. Command execution stopped." return [(None, None, None, message)] assert isinstance(self.sqlexecute, SQLExecute) return self.sqlexecute.run(query) def change_prompt_format(self, arg: str, **_) -> list[tuple]: """ Change the prompt format. """ if not arg: message = "Missing required argument, format." return [(None, None, None, message)] self.prompt_format = self.get_prompt(arg) return [(None, None, None, f"Changed prompt format to {arg}")] def initialize_logging(self) -> None: log_file = os.path.expanduser(self.config["main"]["log_file"]) log_level = self.config["main"]["log_level"] level_map = { "CRITICAL": logging.CRITICAL, "ERROR": logging.ERROR, "WARNING": logging.WARNING, "INFO": logging.INFO, "DEBUG": logging.DEBUG, } # Disable logging if value is NONE by switching to a no-op handler # Set log level to a high value so it doesn't even waste cycles getting called. if log_level.upper() == "NONE": handler: logging.Handler = logging.NullHandler() log_level = "CRITICAL" elif dir_path_exists(log_file): handler = logging.FileHandler(log_file) else: self.echo(f'Error: Unable to open the log file "{log_file}".', err=True, fg="red") return formatter = logging.Formatter("%(asctime)s (%(process)d/%(threadName)s) %(name)s %(levelname)s - %(message)s") handler.setFormatter(formatter) root_logger = logging.getLogger("mycli") root_logger.addHandler(handler) root_logger.setLevel(level_map[log_level.upper()]) logging.captureWarnings(True) root_logger.debug("Initializing mycli logging.") root_logger.debug("Log file %r.", log_file) def read_my_cnf(self, cnf: ConfigObj, keys: list[str]) -> dict[str, Any]: """ Retrieves some keys from a configuration, applies transformations, returns a new configuration. :param cnf: configuration to read :param keys: list of keys to retrieve :returns: tuple, with None for missing keys. """ sections = ["client", "mysqld"] key_transformations = { "mysqld": { "socket": "default_socket", "port": "default_port", "user": "default_user", }, } if self.login_path and self.login_path != "client": sections.append(self.login_path) if self.defaults_suffix: sections.extend([sect + self.defaults_suffix for sect in sections]) configuration: dict[str, Any] = defaultdict(lambda: None) for key in keys: for section in cnf: if section not in sections or key not in cnf[section]: continue new_key = key_transformations.get(section, {}).get(key) or key configuration[new_key] = strip_matching_quotes(cnf[section][key]) return configuration def merge_ssl_with_cnf(self, ssl: dict[str, Any], cnf: dict[str, Any]) -> dict[str, Any]: """Merge SSL configuration dict with cnf dict""" merged = {} merged.update(ssl) prefix = "ssl-" for k, v in cnf.items(): # skip unrelated options if not k.startswith(prefix): continue if v is None: continue # special case because PyMySQL argument is significantly different # from commandline if k == "ssl-verify-server-cert": merged["check_hostname"] = str_to_bool(v) else: # use argument name just strip "ssl-" prefix arg = k[len(prefix) :] merged[arg] = v return merged def connect( self, database: str | None = "", user: str | None = "", passwd: str | None = "", host: str | None = "", port: str | int | None = "", socket: str | None = "", charset: str | None = "", local_infile: bool = False, ssl: dict[str, Any] | None = None, ssh_user: str | None = "", ssh_host: str | None = "", ssh_port: int = 22, ssh_password: str | None = "", ssh_key_filename: str | None = "", init_command: str | None = "", password_file: str | None = "", ) -> None: cnf = { "database": None, "user": None, "password": None, "host": None, "port": None, "socket": None, "default_socket": None, "default-character-set": None, "local-infile": None, "loose-local-infile": None, "ssl-ca": None, "ssl-cert": None, "ssl-key": None, "ssl-cipher": None, "ssl-verify-server-cert": None, } cnf = self.read_my_cnf(self.my_cnf, list(cnf.keys())) # Fall back to config values only if user did not specify a value. database = database or cnf["database"] user = user or cnf["user"] or os.getenv("USER") host = host or cnf["host"] port = port or cnf["port"] ssl_config: dict[str, Any] = ssl or {} int_port = port and int(port) if not int_port: int_port = 3306 if not host or host == "localhost": socket = socket or cnf["socket"] or cnf["default_socket"] or guess_socket_location() passwd = passwd if isinstance(passwd, str) else cnf["password"] charset = charset or cnf["default-character-set"] or "utf8" # Favor whichever local_infile option is set. use_local_infile = False for local_infile_option in (local_infile, cnf["local-infile"], cnf["loose-local-infile"], False): try: use_local_infile = str_to_bool(local_infile_option or '') break except (TypeError, ValueError): pass ssl_config_or_none: dict[str, Any] | None = self.merge_ssl_with_cnf(ssl_config, cnf) # prune lone check_hostname=False if not any(v for v in ssl_config.values()): ssl_config_or_none = None # if the passwd is not specified try to set it using the password_file option password_from_file = self.get_password_from_file(password_file) passwd = passwd if isinstance(passwd, str) else password_from_file passwd = '' if passwd is None else passwd # Connect to the database. def _connect() -> None: try: self.sqlexecute = SQLExecute( database, user, passwd, host, int_port, socket, charset, use_local_infile, ssl_config_or_none, ssh_user, ssh_host, int(ssh_port) if ssh_port else None, ssh_password, ssh_key_filename, init_command, ) except OperationalError as e: if e.args[0] == ERROR_CODE_ACCESS_DENIED: if password_from_file is not None: new_passwd = password_from_file else: new_passwd = click.prompt( f"Password for {user}", hide_input=True, show_default=False, default='', type=str, err=True ) self.sqlexecute = SQLExecute( database, user, new_passwd, host, int_port, socket, charset, use_local_infile, ssl_config_or_none, ssh_user, ssh_host, int(ssh_port) if ssh_port else None, ssh_password, ssh_key_filename, init_command, ) else: raise e try: if not WIN and socket: socket_owner = getpwuid(os.stat(socket).st_uid).pw_name self.echo(f"Connecting to socket {socket}, owned by user {socket_owner}", err=True) try: _connect() except OperationalError as e: # These are "Can't open socket" and 2x "Can't connect" if [code for code in (2001, 2002, 2003) if code == e.args[0]]: self.logger.debug("Database connection failed: %r.", e) self.logger.error("traceback: %r", traceback.format_exc()) self.logger.debug("Retrying over TCP/IP") self.echo(f"Failed to connect to local MySQL server through socket '{socket}':") self.echo(str(e), err=True) self.echo("Retrying over TCP/IP", err=True) # Else fall back to TCP/IP localhost socket = "" host = "localhost" port = 3306 _connect() else: raise e else: host = host or "localhost" port = port or 3306 # Bad ports give particularly daft error messages try: port = int(port) except ValueError: self.echo(f"Error: Invalid port number: '{port}'.", err=True, fg="red") sys.exit(1) _connect() except Exception as e: # Connecting to a database could fail. self.logger.debug("Database connection failed: %r.", e) self.logger.error("traceback: %r", traceback.format_exc()) self.echo(str(e), err=True, fg="red") sys.exit(1) def get_password_from_file(self, password_file: str | None) -> str | None: if not password_file: return None try: with open(password_file) as fp: password = fp.readline().strip() return password except FileNotFoundError: click.secho(f"Password file '{password_file}' not found", err=True, fg="red") sys.exit(1) except PermissionError: click.secho(f"Permission denied reading password file '{password_file}'", err=True, fg="red") sys.exit(1) except IsADirectoryError: click.secho(f"Path '{password_file}' is a directory, not a file", err=True, fg="red") sys.exit(1) except Exception as e: click.secho(f"Error reading password file '{password_file}': {str(e)}", err=True, fg="red") sys.exit(1) def handle_editor_command(self, text: str) -> str: r"""Editor command is any query that is prefixed or suffixed by a '\e'. The reason for a while loop is because a user might edit a query multiple times. For eg: "select * from \e" to edit it in vim, then come back to the prompt with the edited query "select * from blah where q = 'abc'\e" to edit it again. :param text: Document :return: Document """ while special.editor_command(text): filename = special.get_filename(text) query = special.get_editor_query(text) or self.get_last_query() sql, message = special.open_external_editor(filename=filename, sql=query) if message: # Something went wrong. Raise an exception and bail. raise RuntimeError(message) while True: try: assert isinstance(self.prompt_app, PromptSession) text = self.prompt_app.prompt(default=sql) break except KeyboardInterrupt: sql = "" continue return text def handle_clip_command(self, text: str) -> bool: r"""A clip command is any query that is prefixed or suffixed by a '\clip'. :param text: Document :return: Boolean """ if special.clip_command(text): query = special.get_clip_query(text) or self.get_last_query() message = special.copy_query_to_clipboard(sql=query) if message: raise RuntimeError(message) return True return False def handle_prettify_binding(self, text: str) -> str: try: statements = sqlglot.parse(text, read="mysql") except Exception: statements = [] if len(statements) == 1 and statements[0]: pretty_text = statements[0].sql(pretty=True, pad=4, dialect="mysql") else: pretty_text = "" self.toolbar_error_message = "Prettify failed to parse statement" if len(pretty_text) > 0: pretty_text = pretty_text + ";" return pretty_text def handle_unprettify_binding(self, text: str) -> str: try: statements = sqlglot.parse(text, read="mysql") except Exception: statements = [] if len(statements) == 1 and statements[0]: unpretty_text = statements[0].sql(pretty=False, dialect="mysql") else: unpretty_text = "" self.toolbar_error_message = "Unprettify failed to parse statement" if len(unpretty_text) > 0: unpretty_text = unpretty_text + ";" return unpretty_text def run_cli(self) -> None: iterations = 0 sqlexecute = self.sqlexecute assert isinstance(sqlexecute, SQLExecute) logger = self.logger self.configure_pager() if self.smart_completion: self.refresh_completions() history_file = os.path.expanduser(os.environ.get("MYCLI_HISTFILE", "~/.mycli-history")) if dir_path_exists(history_file): history = FileHistoryWithTimestamp(history_file) else: history = None self.echo( f'Error: Unable to open the history file "{history_file}". Your query history will not be saved.', err=True, fg="red", ) key_bindings = mycli_bindings(self) if not self.less_chatty: print(sqlexecute.server_info) print("mycli", __version__) print(SUPPORT_INFO) print("Thanks to the contributor -", thanks_picker()) def get_message() -> ANSI: prompt = self.get_prompt(self.prompt_format) if self.prompt_format == self.default_prompt and len(prompt) > self.max_len_prompt: prompt = self.get_prompt(self.default_prompt_splitln) prompt = prompt.replace("\\x1b", "\x1b") return ANSI(prompt) def get_continuation(width: int, _two: int, _three: int) -> AnyFormattedText: if self.multiline_continuation_char == "": continuation = "" elif self.multiline_continuation_char: left_padding = width - len(self.multiline_continuation_char) continuation = " " * max((left_padding - 1), 0) + self.multiline_continuation_char + " " else: continuation = " " return [("class:continuation", continuation)] def show_suggestion_tip() -> bool: return iterations < 2 # Keep track of whether or not the query is mutating. In case # of a multi-statement query, the overall query is considered # mutating if any one of the component statements is mutating mutating = False def output_res(res: Generator[tuple], start: float) -> None: nonlocal mutating result_count = 0 for title, cur, headers, status in res: logger.debug("headers: %r", headers) logger.debug("rows: %r", cur) logger.debug("status: %r", status) threshold = 1000 if is_select(status) and cur and cur.rowcount > threshold: self.echo( f"The result set has more than {threshold} rows.", fg="red", ) if not confirm("Do you want to continue?"): self.echo("Aborted!", err=True, fg="red") break if self.auto_vertical_output: if self.prompt_app is not None: max_width = self.prompt_app.output.get_size().columns else: max_width = DEFAULT_WIDTH else: max_width = None formatted = self.format_output( title, cur, headers, special.is_expanded_output(), special.is_redirected(), max_width, ) t = time() - start try: if result_count > 0: self.echo("") try: self.output(formatted, status) except KeyboardInterrupt: pass if self.beep_after_seconds > 0 and t >= self.beep_after_seconds: self.bell() if special.is_timing_enabled(): self.echo(f"Time: {t:0.03f}s") except KeyboardInterrupt: pass start = time() result_count += 1 mutating = mutating or is_mutating(status) def one_iteration(text: str | None = None) -> None: if text is None: try: assert self.prompt_app is not None text = self.prompt_app.prompt() except KeyboardInterrupt: return special.set_expanded_output(False) special.set_forced_horizontal_output(False) try: text = self.handle_editor_command(text) except RuntimeError as e: logger.error("sql: %r, error: %r", text, e) logger.error("traceback: %r", traceback.format_exc()) self.echo(str(e), err=True, fg="red") return try: if self.handle_clip_command(text): return except RuntimeError as e: logger.error("sql: %r, error: %r", text, e) logger.error("traceback: %r", traceback.format_exc()) self.echo(str(e), err=True, fg="red") return # LLM command support while special.is_llm_command(text): start = time() try: assert sqlexecute.conn is not None cur = sqlexecute.conn.cursor() context, sql, duration = special.handle_llm(text, cur) if context: click.echo("LLM Response:") click.echo(context) click.echo("---") if special.is_timing_enabled(): click.echo(f"Time: {duration:.2f} seconds") text = self.prompt_app.prompt(default=sql or '') except KeyboardInterrupt: return except special.FinishIteration as e: if e.results: return output_res(e.results, start) else: return None except RuntimeError as e: logger.error("sql: %r, error: %r", text, e) logger.error("traceback: %r", traceback.format_exc()) self.echo(str(e), err=True, fg="red") return text = text.strip() if not text: return if is_redirect_command(text): sql_part, command_part, file_operator_part, file_part = get_redirect_components(text) text = sql_part or '' try: special.set_redirect(command_part, file_operator_part, file_part) except (FileNotFoundError, OSError, RuntimeError) as e: logger.error("sql: %r, error: %r", text, e) logger.error("traceback: %r", traceback.format_exc()) self.echo(str(e), err=True, fg="red") return if self.destructive_warning: destroy = confirm_destructive_query(text) if destroy is None: pass # Query was not destructive. Nothing to do here. elif destroy is True: self.echo("Your call!") else: self.echo("Wise choice!") return else: destroy = True try: logger.debug("sql: %r", text) special.write_tee(self.get_prompt(self.prompt_format) + text) if self.logfile: self.logfile.write(f"\n# {datetime.now()}\n") self.logfile.write(text) self.logfile.write("\n") successful = False start = time() res = sqlexecute.run(text) self.main_formatter.query = text self.redirect_formatter.query = text successful = True output_res(res, start) special.unset_once_if_written(self.post_redirect_command) special.flush_pipe_once_if_written(self.post_redirect_command) except err.InterfaceError: logger.debug("Attempting to reconnect.") self.echo("Reconnecting...", fg="yellow") try: sqlexecute.connect() logger.debug("Reconnected successfully.") one_iteration(text) return # OK to just return, cuz the recursion call runs to the end. except OperationalError as e2: logger.debug("Reconnect failed. e: %r", e2) self.echo(str(e2), err=True, fg="red") # If reconnection failed, don't proceed further. return except EOFError as e: raise e except KeyboardInterrupt: # get last connection id connection_id_to_kill = sqlexecute.connection_id or 0 # some mysql compatible databases may not implemente connection_id() if connection_id_to_kill > 0: logger.debug("connection id to kill: %r", connection_id_to_kill) # Restart connection to the database sqlexecute.connect() try: for _title, _cur, _headers, status in sqlexecute.run(f"kill {connection_id_to_kill}"): status_str = str(status).lower() if status_str.find("ok") > -1: logger.debug("cancelled query, connection id: %r, sql: %r", connection_id_to_kill, text) self.echo(f"Cancelled query id: {connection_id_to_kill}", err=True, fg="blue") else: logger.debug( "Failed to confirm query cancellation, connection id: %r, sql: %r", connection_id_to_kill, text, ) self.echo(f"Failed to confirm query cancellation, id: {connection_id_to_kill}", err=True, fg="red") except Exception as e: self.echo(f"Encountered error while cancelling query: {e}", err=True, fg="red") else: logger.debug("Did not get a connection id, skip cancelling query") self.echo("Did not get a connection id, skip cancelling query", err=True, fg="red") except NotImplementedError: self.echo("Not Yet Implemented.", fg="yellow") except OperationalError as e1: logger.debug("Exception: %r", e1) if e1.args[0] in (2003, 2006, 2013): logger.debug("Attempting to reconnect.") self.echo("Reconnecting...", fg="yellow") try: sqlexecute.connect() logger.debug("Reconnected successfully.") one_iteration(text) return # OK to just return, cuz the recursion call runs to the end. except OperationalError as e2: logger.debug("Reconnect failed. e: %r", e2) self.echo(str(e2), err=True, fg="red") # If reconnection failed, don't proceed further. return else: logger.error("sql: %r, error: %r", text, e1) logger.error("traceback: %r", traceback.format_exc()) self.echo(str(e1), err=True, fg="red") except Exception as e: logger.error("sql: %r, error: %r", text, e) logger.error("traceback: %r", traceback.format_exc()) self.echo(str(e), err=True, fg="red") else: if is_dropping_database(text, sqlexecute.dbname): sqlexecute.dbname = None sqlexecute.connect() # Refresh the table names and column names if necessary. if need_completion_refresh(text): self.refresh_completions(reset=need_completion_reset(text)) finally: if self.logfile is False: self.echo("Warning: This query was not logged.", err=True, fg="red") query = Query(text, successful, mutating) self.query_history.append(query) get_toolbar_tokens = create_toolbar_tokens_func(self, show_suggestion_tip) if self.wider_completion_menu: complete_style = CompleteStyle.MULTI_COLUMN else: complete_style = CompleteStyle.COLUMN with self._completer_lock: if self.key_bindings == "vi": editing_mode = EditingMode.VI else: editing_mode = EditingMode.EMACS self.prompt_app = PromptSession( lexer=PygmentsLexer(MyCliLexer), reserve_space_for_menu=self.get_reserved_space(), message=get_message, prompt_continuation=get_continuation, bottom_toolbar=get_toolbar_tokens, complete_style=complete_style, input_processors=[ ConditionalProcessor( processor=HighlightMatchingBracketProcessor(chars="[](){}"), filter=HasFocus(DEFAULT_BUFFER) & ~IsDone() ) ], tempfile_suffix=".sql", completer=DynamicCompleter(lambda: self.completer), history=history, auto_suggest=AutoSuggestFromHistory(), complete_while_typing=True, multiline=cli_is_multiline(self), style=style_factory(self.syntax_style, self.cli_style), include_default_pygments_style=False, key_bindings=key_bindings, enable_open_in_editor=True, enable_system_prompt=True, enable_suspend=True, editing_mode=editing_mode, search_ignore_case=True, ) try: while True: one_iteration() iterations += 1 except EOFError: special.close_tee() if not self.less_chatty: self.echo("Goodbye!") def log_output(self, output: str) -> None: """Log the output in the audit log, if it's enabled.""" if isinstance(self.logfile, TextIOWrapper): click.echo(output, file=self.logfile) def echo(self, s: str, **kwargs) -> None: """Print a message to stdout. The message will be logged in the audit log, if enabled. All keyword arguments are passed to click.echo(). """ self.log_output(s) click.secho(s, **kwargs) def bell(self) -> None: """Print a bell on the stderr.""" click.secho("\a", err=True, nl=False) def get_output_margin(self, status: str | None = None) -> int: """Get the output margin (number of rows for the prompt, footer and timing message.""" margin = self.get_reserved_space() + self.get_prompt(self.prompt_format).count("\n") + 1 if special.is_timing_enabled(): margin += 1 if status: margin += 1 + status.count("\n") return margin def output(self, output: itertools.chain[str], status: str | None = None) -> None: """Output text to stdout or a pager command. The status text is not outputted to pager or files. The message will be logged in the audit log, if enabled. The message will be written to the tee file, if enabled. The message will be written to the output file, if enabled. """ if output: if self.prompt_app is not None: size = self.prompt_app.output.get_size() size_columns = size.columns size_rows = size.rows else: size_columns = DEFAULT_WIDTH size_rows = DEFAULT_HEIGHT margin = self.get_output_margin(status) fits = True buf = [] output_via_pager = self.explicit_pager and special.is_pager_enabled() for i, line in enumerate(output, 1): self.log_output(line) special.write_tee(line) special.write_once(line) special.write_pipe_once(line) if special.is_redirected(): pass elif fits or output_via_pager: # buffering buf.append(line) if len(line) > size_columns or i > (size_rows - margin): fits = False if not self.explicit_pager and special.is_pager_enabled(): # doesn't fit, use pager output_via_pager = True if not output_via_pager: # doesn't fit, flush buffer for buf_line in buf: click.secho(buf_line) buf = [] else: click.secho(line) if buf: if output_via_pager: def newlinewrapper(text: list[str]) -> Generator[str, None, None]: for line in text: yield line + "\n" click.echo_via_pager(newlinewrapper(buf)) else: for line in buf: click.secho(line) if status: self.log_output(status) click.secho(status) def configure_pager(self) -> None: # Provide sane defaults for less if they are empty. if not os.environ.get("LESS"): os.environ["LESS"] = "-RXF" cnf = self.read_my_cnf(self.my_cnf, ["pager", "skip-pager"]) cnf_pager = cnf["pager"] or self.config["main"]["pager"] # help Windows users who haven't edited the default myclirc if WIN and cnf_pager == 'less' and not shutil.which(cnf_pager): cnf_pager = 'more' if cnf_pager: special.set_pager(cnf_pager) self.explicit_pager = True else: self.explicit_pager = False if cnf["skip-pager"] or not self.config["main"].as_bool("enable_pager"): special.disable_pager() def refresh_completions(self, reset: bool = False) -> list[tuple]: if reset: with self._completer_lock: self.completer.reset_completions() assert self.sqlexecute is not None self.completion_refresher.refresh( self.sqlexecute, self._on_completions_refreshed, { "smart_completion": self.smart_completion, "supported_formats": self.main_formatter.supported_formats, "keyword_casing": self.completer.keyword_casing, }, ) return [(None, None, None, "Auto-completion refresh started in the background.")] def _on_completions_refreshed(self, new_completer: SQLCompleter) -> None: """Swap the completer object in cli with the newly created completer.""" with self._completer_lock: self.completer = new_completer if self.prompt_app: # After refreshing, redraw the CLI to clear the statusbar # "Refreshing completions..." indicator self.prompt_app.app.invalidate() def get_completions(self, text: str, cursor_position: int) -> Iterable[Completion]: with self._completer_lock: return self.completer.get_completions(Document(text=text, cursor_position=cursor_position), None) def get_prompt(self, string: str) -> str: sqlexecute = self.sqlexecute assert sqlexecute is not None assert sqlexecute.server_info is not None assert sqlexecute.server_info.species is not None host = self.login_path if self.login_path and self.login_path_as_host else sqlexecute.host now = datetime.now() string = string.replace("\\u", sqlexecute.user or "(none)") string = string.replace("\\h", host or "(none)") string = string.replace("\\d", sqlexecute.dbname or "(none)") string = string.replace("\\t", sqlexecute.server_info.species.name) string = string.replace("\\n", "\n") string = string.replace("\\D", now.strftime("%a %b %d %H:%M:%S %Y")) string = string.replace("\\m", now.strftime("%M")) string = string.replace("\\P", now.strftime("%p")) string = string.replace("\\R", now.strftime("%H")) string = string.replace("\\r", now.strftime("%I")) string = string.replace("\\s", now.strftime("%S")) string = string.replace("\\p", str(sqlexecute.port)) string = string.replace("\\A", self.dsn_alias or "(none)") string = string.replace("\\_", " ") return string def run_query(self, query: str, new_line: bool = True) -> None: """Runs *query*.""" assert self.sqlexecute is not None results = self.sqlexecute.run(query) for result in results: title, cur, headers, status = result self.main_formatter.query = query self.redirect_formatter.query = query output = self.format_output( title, cur, headers, special.is_expanded_output(), special.is_redirected(), ) for line in output: click.echo(line, nl=new_line) def format_output( self, title: str | None, cur: Cursor | list[tuple] | None, headers: list[str] | None, expanded: bool = False, is_redirected: bool = False, max_width: int | None = None, ) -> itertools.chain[str]: if is_redirected: use_formatter = self.redirect_formatter else: use_formatter = self.main_formatter expanded = expanded or use_formatter.format_name == "vertical" output: itertools.chain[str] = itertools.chain() output_kwargs = {"dialect": "unix", "disable_numparse": True, "preserve_whitespace": True, "style": self.output_style} if use_formatter.format_name not in sql_format.supported_formats: output_kwargs["preprocessors"] = (preprocessors.align_decimals,) if title: # Only print the title if it's not None. output = itertools.chain(output, [title]) if cur: column_types = None if isinstance(cur, Cursor): def get_col_type(col) -> type: col_type = FIELD_TYPES.get(col[1], str) return col_type if type(col_type) is type else str column_types = [get_col_type(tup) for tup in cur.description] if max_width is not None: cur = list(cur) formatted = use_formatter.format_output( cur, headers, format_name="vertical" if expanded else None, column_types=column_types, **output_kwargs, ) if isinstance(formatted, str): formatted = formatted.splitlines() formatted = iter(formatted) if not expanded and max_width and headers and cur: first_line = next(formatted) if len(strip_ansi(first_line)) > max_width: formatted = use_formatter.format_output( cur, headers, format_name="vertical", column_types=column_types, **output_kwargs, ) if isinstance(formatted, str): formatted = iter(formatted.splitlines()) else: formatted = itertools.chain([first_line], formatted) output = itertools.chain(output, formatted) return output def get_reserved_space(self) -> int: """Get the number of lines to reserve for the completion menu.""" reserved_space_ratio = 0.45 max_reserved_space = 8 _, height = shutil.get_terminal_size() return min(int(round(height * reserved_space_ratio)), max_reserved_space) def get_last_query(self) -> str | None: """Get the last query executed or None.""" return self.query_history[-1][0] if self.query_history else None @click.command() @click.option("-h", "--host", envvar="MYSQL_HOST", help="Host address of the database.") @click.option("-P", "--port", envvar="MYSQL_TCP_PORT", type=int, help="Port number to use for connection. Honors $MYSQL_TCP_PORT.") @click.option("-u", "--user", help="User name to connect to the database.") @click.option("-S", "--socket", envvar="MYSQL_UNIX_PORT", help="The socket file to use for connection.") @click.option("-p", "--password", "password", envvar="MYSQL_PWD", type=str, help="Password to connect to the database.") @click.option("--pass", "password", envvar="MYSQL_PWD", type=str, help="Password to connect to the database.") @click.option("--ssh-user", help="User name to connect to ssh server.") @click.option("--ssh-host", help="Host name to connect to ssh server.") @click.option("--ssh-port", default=22, help="Port to connect to ssh server.") @click.option("--ssh-password", help="Password to connect to ssh server.") @click.option("--ssh-key-filename", help="Private key filename (identify file) for the ssh connection.") @click.option("--ssh-config-path", help="Path to ssh configuration.", default=os.path.expanduser("~") + "/.ssh/config") @click.option("--ssh-config-host", help="Host to connect to ssh server reading from ssh configuration.") @click.option("--ssl", "ssl_enable", is_flag=True, help="Enable SSL for connection (automatically enabled with other flags).") @click.option("--ssl-ca", help="CA file in PEM format.", type=click.Path(exists=True)) @click.option("--ssl-capath", help="CA directory.") @click.option("--ssl-cert", help="X509 cert in PEM format.", type=click.Path(exists=True)) @click.option("--ssl-key", help="X509 key in PEM format.", type=click.Path(exists=True)) @click.option("--ssl-cipher", help="SSL cipher to use.") @click.option( "--tls-version", type=click.Choice(["TLSv1", "TLSv1.1", "TLSv1.2", "TLSv1.3"], case_sensitive=False), help="TLS protocol version for secure connection.", ) @click.option( "--ssl-verify-server-cert", is_flag=True, help=("""Verify server's "Common Name" in its cert against hostname used when connecting. This option is disabled by default."""), ) # as of 2016-02-15 revocation list is not supported by underling PyMySQL # library (--ssl-crl and --ssl-crlpath options in vanilla mysql client) @click.version_option(__version__, "-V", "--version", help="Output mycli's version.") @click.option("-v", "--verbose", is_flag=True, help="Verbose output.") @click.option("-D", "--database", "dbname", help="Database to use.") @click.option("-d", "--dsn", default="", envvar="DSN", help="Use DSN configured into the [alias_dsn] section of myclirc file.") @click.option("--list-dsn", "list_dsn", is_flag=True, help="list of DSN configured into the [alias_dsn] section of myclirc file.") @click.option("--list-ssh-config", "list_ssh_config", is_flag=True, help="list ssh configurations in the ssh config (requires paramiko).") @click.option("-R", "--prompt", "prompt", help=f'Prompt format (Default: "{MyCli.default_prompt}").') @click.option("-l", "--logfile", type=click.File(mode="a", encoding="utf-8"), help="Log every query and its results to a file.") @click.option("--defaults-group-suffix", type=str, help="Read MySQL config groups with the specified suffix.") @click.option("--defaults-file", type=click.Path(), help="Only read MySQL options from the given file.") @click.option("--myclirc", type=click.Path(), default="~/.myclirc", help="Location of myclirc file.") @click.option( "--auto-vertical-output", is_flag=True, help="Automatically switch to vertical output mode if the result is wider than the terminal width.", ) @click.option("-t", "--table", is_flag=True, help="Display batch output in table format.") @click.option("--csv", is_flag=True, help="Display batch output in CSV format.") @click.option("--warn/--no-warn", default=None, help="Warn before running a destructive query.") @click.option("--local-infile", type=bool, help="Enable/disable LOAD DATA LOCAL INFILE.") @click.option("-g", "--login-path", type=str, help="Read this path from the login file.") @click.option("-e", "--execute", type=str, help="Execute command and quit.") @click.option("--init-command", type=str, help="SQL statement to execute after connecting.") @click.option("--charset", type=str, help="Character set for MySQL session.") @click.option( "--password-file", type=click.Path(), help="File or FIFO path containing the password to connect to the db if not specified otherwise." ) @click.argument("database", default="", nargs=1) def cli( database: str, user: str | None, host: str | None, port: int | None, socket: str | None, password: str | None, dbname: str | None, verbose: bool, prompt: str | None, logfile: TextIOWrapper | None, defaults_group_suffix: str | None, defaults_file: str | None, login_path: str | None, auto_vertical_output: bool, local_infile: bool, ssl_enable: bool, ssl_ca: str | None, ssl_capath: str | None, ssl_cert: str | None, ssl_key: str | None, ssl_cipher: str | None, tls_version: str | None, ssl_verify_server_cert: bool, table: bool, csv: bool, warn: bool | None, execute: str | None, myclirc: str, dsn: str, list_dsn: str | None, ssh_user: str | None, ssh_host: str | None, ssh_port: int, ssh_password: str | None, ssh_key_filename: str | None, list_ssh_config: bool, ssh_config_path: str, ssh_config_host: str | None, init_command: str | None, charset: str | None, password_file: str | None, ) -> None: """A MySQL terminal client with auto-completion and syntax highlighting. \b Examples: - mycli my_database - mycli -u my_user -h my_host.com my_database - mycli mysql://my_user@my_host.com:3306/my_database """ mycli = MyCli( prompt=prompt, logfile=logfile, defaults_suffix=defaults_group_suffix, defaults_file=defaults_file, login_path=login_path, auto_vertical_output=auto_vertical_output, warn=warn, myclirc=myclirc, ) if list_dsn: try: alias_dsn = mycli.config["alias_dsn"] except KeyError: click.secho("Invalid DSNs found in the config file. Please check the \"[alias_dsn]\" section in myclirc.", err=True, fg="red") sys.exit(1) except Exception as e: click.secho(str(e), err=True, fg="red") sys.exit(1) for alias, value in alias_dsn.items(): if verbose: click.secho(f"{alias} : {value}") else: click.secho(alias) sys.exit(0) if list_ssh_config: ssh_config = read_ssh_config(ssh_config_path) for host in ssh_config.get_hostnames(): if verbose: host_config = ssh_config.lookup(host) click.secho(f"{host} : {host_config.get('hostname')}") else: click.secho(host) sys.exit(0) # Choose which ever one has a valid value. database = dbname or database dsn_uri = None # Treat the database argument as a DSN alias only if it matches a configured alias if ( database and "://" not in database and not any([user, password, host, port, login_path]) and database in mycli.config.get("alias_dsn", {}) ): dsn, database = database, "" if database and "://" in database: dsn_uri, database = database, "" if dsn: try: dsn_uri = mycli.config["alias_dsn"][dsn] except KeyError: click.secho( "Could not find the specified DSN in the config file. Please check the \"[alias_dsn]\" section in your myclirc.", err=True, fg="red", ) sys.exit(1) else: mycli.dsn_alias = dsn if dsn_uri: uri = urlparse(dsn_uri) if not database: database = uri.path[1:] # ignore the leading fwd slash if not user and uri.username is not None: user = unquote(uri.username) if not password and uri.password is not None: password = unquote(uri.password) if not host: host = uri.hostname if not port: port = uri.port if uri.query: dsn_params = parse_qs(uri.query) else: dsn_params = {} if params := dsn_params.get('ssl'): ssl_enable = ssl_enable or (params[0].lower() == 'true') if params := dsn_params.get('ssl_ca'): ssl_ca = ssl_ca or params[0] ssl_enable = True if params := dsn_params.get('ssl_capath'): ssl_capath = ssl_capath or params[0] ssl_enable = True if params := dsn_params.get('ssl_cert'): ssl_cert = ssl_cert or params[0] ssl_enable = True if params := dsn_params.get('ssl_key'): ssl_key = ssl_key or params[0] ssl_enable = True if params := dsn_params.get('ssl_cipher'): ssl_cipher = ssl_cipher or params[0] ssl_enable = True if params := dsn_params.get('tls_version'): tls_version = tls_version or params[0] ssl_enable = True if params := dsn_params.get('ssl_verify_server_cert'): ssl_verify_server_cert = ssl_verify_server_cert or (params[0].lower() == 'true') ssl_enable = True ssl = { "enable": ssl_enable, "ca": ssl_ca and os.path.expanduser(ssl_ca), "cert": ssl_cert and os.path.expanduser(ssl_cert), "key": ssl_key and os.path.expanduser(ssl_key), "capath": ssl_capath, "cipher": ssl_cipher, "tls_version": tls_version, "check_hostname": ssl_verify_server_cert, } # remove empty ssl options ssl = {k: v for k, v in ssl.items() if v is not None} if ssh_config_host: ssh_config = read_ssh_config(ssh_config_path).lookup(ssh_config_host) ssh_host = ssh_host if ssh_host else ssh_config.get("hostname") ssh_user = ssh_user if ssh_user else ssh_config.get("user") if ssh_config.get("port") and ssh_port == 22: # port has a default value, overwrite it if it's in the config ssh_port = int(ssh_config.get("port")) ssh_key_filename = ssh_key_filename if ssh_key_filename else ssh_config.get("identityfile", [None])[0] ssh_key_filename = ssh_key_filename and os.path.expanduser(ssh_key_filename) # Merge init-commands: global, DSN-specific, then CLI init_cmds: list[str] = [] # 1) Global init-commands global_section = mycli.config.get("init-commands", {}) for _, val in global_section.items(): if isinstance(val, (list, tuple)): init_cmds.extend(val) elif val: init_cmds.append(val) # 2) DSN-specific init-commands if dsn: alias_section = mycli.config.get("alias_dsn.init-commands", {}) if dsn in alias_section: val = alias_section.get(dsn) if isinstance(val, (list, tuple)): init_cmds.extend(val) elif val: init_cmds.append(val) # 3) CLI-provided init_command if init_command: init_cmds.append(init_command) combined_init_cmd = "; ".join(cmd.strip() for cmd in init_cmds if cmd) mycli.connect( database=database, user=user, passwd=password, host=host, port=port, socket=socket, local_infile=local_infile, ssl=ssl, ssh_user=ssh_user, ssh_host=ssh_host, ssh_port=ssh_port, ssh_password=ssh_password, ssh_key_filename=ssh_key_filename, init_command=combined_init_cmd, charset=charset, password_file=password_file, ) if combined_init_cmd: click.echo(f"Executing init-command: {combined_init_cmd}", err=True) mycli.logger.debug("Launch Params: \n\tdatabase: %r\tuser: %r\thost: %r\tport: %r", database, user, host, port) # --execute argument if execute: try: if csv: mycli.main_formatter.format_name = "csv" if execute.endswith(r"\G"): execute = execute[:-2] elif table: if execute.endswith(r"\G"): execute = execute[:-2] else: mycli.main_formatter.format_name = "tsv" mycli.run_query(execute) sys.exit(0) except Exception as e: click.secho(str(e), err=True, fg="red") sys.exit(1) if sys.stdin.isatty(): mycli.run_cli() else: stdin = click.get_text_stream("stdin") try: stdin_text = stdin.read() except MemoryError: click.secho("Failed! Ran out of memory.", err=True, fg="red") click.secho("You might want to try the official mysql client.", err=True, fg="red") click.secho("Sorry... :(", err=True, fg="red") sys.exit(1) if mycli.destructive_warning and is_destructive(stdin_text): try: sys.stdin = open("/dev/tty") warn_confirmed = confirm_destructive_query(stdin_text) except (IOError, OSError): mycli.logger.warning("Unable to open TTY as stdin.") if not warn_confirmed: sys.exit(0) try: new_line = True if csv: mycli.main_formatter.format_name = "csv" elif not table: mycli.main_formatter.format_name = "tsv" mycli.run_query(stdin_text, new_line=new_line) sys.exit(0) except Exception as e: click.secho(str(e), err=True, fg="red") sys.exit(1) def need_completion_refresh(queries: str) -> bool: """Determines if the completion needs a refresh by checking if the sql statement is an alter, create, drop or change db.""" for query in sqlparse.split(queries): try: first_token = query.split()[0] if first_token.lower() in ("alter", "create", "use", "\\r", "\\u", "connect", "drop", "rename"): return True except Exception: return False return False def need_completion_reset(queries: str) -> bool: """Determines if the statement is a database switch such as 'use' or '\\u'. When a database is changed the existing completions must be reset before we start the completion refresh for the new database. """ for query in sqlparse.split(queries): try: first_token = query.split()[0] if first_token.lower() in ("use", "\\u"): return True except Exception: return False return False def is_mutating(status: str | None) -> bool: """Determines if the statement is mutating based on the status.""" if not status: return False mutating = {"insert", "update", "delete", "alter", "create", "drop", "replace", "truncate", "load", "rename"} return status.split(None, 1)[0].lower() in mutating def is_select(status: str | None) -> bool: """Returns true if the first word in status is 'select'.""" if not status: return False return status.split(None, 1)[0].lower() == "select" def thanks_picker() -> str: import mycli lines = (resources.read_text(mycli, "AUTHORS") + resources.read_text(mycli, "SPONSORS")).split("\n") contents = [] for line in lines: if m := re.match(r"^ *\* (.*)", line): contents.append(m.group(1)) return choice(contents) if contents else 'our sponsors' @prompt_register("edit-and-execute-command") def edit_and_execute(event: KeyPressEvent) -> None: """Different from the prompt-toolkit default, we want to have a choice not to execute a query after editing, hence validate_and_handle=False.""" buff = event.current_buffer buff.open_in_editor(validate_and_handle=False) def read_ssh_config(ssh_config_path: str): ssh_config = paramiko.config.SSHConfig() try: with open(ssh_config_path) as f: ssh_config.parse(f) except FileNotFoundError as e: click.secho(str(e), err=True, fg="red") sys.exit(1) # Paramiko prior to version 2.7 raises Exception on parse errors. # In 2.7 it has become paramiko.ssh_exception.SSHException, # but let's catch everything for compatibility except Exception as err: click.secho(f"Could not parse SSH configuration file {ssh_config_path}:\n{err} ", err=True, fg="red") sys.exit(1) else: return ssh_config if __name__ == "__main__": cli() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/myclirc0000644000175100017510000001437015101406164015065 0ustar00runnerrunner# vi: ft=dosini [main] # Enables context sensitive auto-completion. If this is disabled the all # possible completions will be listed. smart_completion = True # Multi-line mode allows breaking up the sql statements into multiple lines. If # this is set to True, then the end of the statements must have a semi-colon. # If this is set to False then sql statements can't be split into multiple # lines. End of line (return) is considered as the end of the statement. multi_line = False # Destructive warning mode will alert you before executing a sql statement # that may cause harm to the database such as "drop table", "drop database" # or "shutdown". destructive_warning = True # log_file location. log_file = ~/.mycli.log # Default log level. Possible values: "CRITICAL", "ERROR", "WARNING", "INFO" # and "DEBUG". "NONE" disables logging. log_level = INFO # Log every query and its results to a file. Enable this by uncommenting the # line below. # audit_log = ~/.mycli-audit.log # Timing of SQL statements and table rendering, or LLM commands. timing = True # Beep after long-running queries are completed; 0 to disable. beep_after_seconds = 0 # Table format. Possible values: ascii, ascii_escaped, csv, csv-noheader, # csv-tab, csv-tab-noheader, double, fancy_grid, github, grid, html, jira, # jsonl, jsonl_escaped, latex, latex_booktabs, mediawiki, minimal, moinmoin, # mysql, mysql_unicode, orgtbl, pipe, plain, psql, psql_unicode, rst, simple, # sql-insert, sql-update, sql-update-1, sql-update-2, textile, tsv, # tsv_noheader, vertical. # Recommended: ascii. table_format = ascii # Redirected otuput format # Recommended: csv. redirect_format = csv # A command to run after a successful output redirect, with {} to be replaced # with the escaped filename. Mac example: echo {} | pbcopy. Escaping is not # reliable/safe on Windows. post_redirect_command = # Syntax coloring style. Possible values (many support the "-dark" suffix): # manni, igor, xcode, vim, autumn, vs, rrt, native, perldoc, borland, tango, emacs, # friendly, monokai, paraiso, colorful, murphy, bw, pastie, paraiso, trac, default, # fruity. # Screenshots at http://mycli.net/syntax # Can be further modified in [colors] syntax_style = default # Keybindings: Possible values: emacs, vi. # Emacs mode: Ctrl-A is home, Ctrl-E is end. All emacs keybindings are available in the REPL. # When Vi mode is enabled you can use modal editing features offered by Vi in the REPL. key_bindings = emacs # Enabling this option will show the suggestions in a wider menu. Thus more items are suggested. wider_completion_menu = False # MySQL prompt # \D - The full current date # \d - Database name # \h - Hostname of the server # \m - Minutes of the current time # \n - Newline # \P - AM/PM # \p - Port # \R - The current time, in 24-hour military time (0-23) # \r - The current time, standard 12-hour time (1-12) # \s - Seconds of the current time # \t - Product type (Percona, MySQL, MariaDB, TiDB) # \A - DSN alias name (from the [alias_dsn] section) # \u - Username # \x1b[...m - insert ANSI escape sequence prompt = '\t \u@\h:\d> ' prompt_continuation = '->' # Skip intro info on startup and outro info on exit less_chatty = False # Use alias from --login-path instead of host name in prompt login_path_as_host = False # Cause result sets to be displayed vertically if they are too wide for the current window, # and using normal tabular format otherwise. (This applies to statements terminated by ; or \G.) auto_vertical_output = False # keyword casing preference. Possible values "lower", "upper", "auto" keyword_casing = auto # disabled pager on startup enable_pager = True # Choose a specific pager pager = 'less' [keys] # possible values: auto, fzf, reverse_isearch control_r = auto # Custom colors for the completion menu, toolbar, etc. [colors] completion-menu.completion.current = 'bg:#ffffff #000000' completion-menu.completion = 'bg:#008888 #ffffff' completion-menu.meta.completion.current = 'bg:#44aaaa #000000' completion-menu.meta.completion = 'bg:#448888 #ffffff' completion-menu.multi-column-meta = 'bg:#aaffff #000000' scrollbar.arrow = 'bg:#003333' scrollbar = 'bg:#00aaaa' selected = '#ffffff bg:#6666aa' search = '#ffffff bg:#4444aa' search.current = '#ffffff bg:#44aa44' bottom-toolbar = 'bg:#222222 #aaaaaa' bottom-toolbar.off = 'bg:#222222 #888888' bottom-toolbar.on = 'bg:#222222 #ffffff' search-toolbar = 'noinherit bold' search-toolbar.text = 'nobold' system-toolbar = 'noinherit bold' arg-toolbar = 'noinherit bold' arg-toolbar.text = 'nobold' bottom-toolbar.transaction.valid = 'bg:#222222 #00ff5f bold' bottom-toolbar.transaction.failed = 'bg:#222222 #ff005f bold' # style classes for colored table output output.header = "#00ff5f bold" output.odd-row = "" output.even-row = "" output.null = "#808080" # SQL syntax highlighting overrides # sql.comment = 'italic #408080' # sql.comment.multi-line = '' # sql.comment.single-line = '' # sql.comment.optimizer-hint = '' # sql.escape = 'border:#FF0000' # sql.keyword = 'bold #008000' # sql.datatype = 'nobold #B00040' # sql.literal = '' # sql.literal.date = '' # sql.symbol = '' # sql.quoted-schema-object = '' # sql.quoted-schema-object.escape = '' # sql.constant = '#880000' # sql.function = '#0000FF' # sql.variable = '#19177C' # sql.number = '#666666' # sql.number.binary = '' # sql.number.float = '' # sql.number.hex = '' # sql.number.integer = '' # sql.operator = '#666666' # sql.punctuation = '' # sql.string = '#BA2121' # sql.string.double-quouted = '' # sql.string.escape = 'bold #BB6622' # sql.string.single-quoted = '' # sql.whitespace = '' # Favorite queries. # You can add your favorite queries here. They will be available in the # REPL when you type `\f` or `\f `. [favorite_queries] # example = "SELECT * FROM example_table WHERE id = 1" # Initial commands to execute when connecting to any database. [init-commands] # read_only = "SET SESSION TRANSACTION READ ONLY" # Use the -d option to reference a DSN. # Special characters in passwords and other strings can be escaped with URL encoding. [alias_dsn] # example_dsn = mysql://[user[:password]@][host][:port][/dbname] # Initial commands to execute when connecting to a DSN alias. [alias_dsn.init-commands] # Define one or more SQL statements per alias (semicolon-separated). # example_dsn = "SET sql_select_limit=1000; SET time_zone='+00:00'" ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1762004092.2868173 mycli-1.41.0/mycli/packages/0000755000175100017510000000000015101406174015252 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/packages/__init__.py0000644000175100017510000000000015101406164017350 0ustar00runnerrunner././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/packages/completion_engine.py0000644000175100017510000003067115101406164021330 0ustar00runnerrunnerfrom typing import Any import sqlparse from sqlparse.sql import Comparison, Identifier, Token, Where from mycli.packages.parseutils import extract_tables, find_prev_keyword, last_word from mycli.packages.special.main import parse_special_command def suggest_type(full_text: str, text_before_cursor: str) -> list[dict[str, Any]]: """Takes the full_text that is typed so far and also the text before the cursor to suggest completion type and scope. Returns a tuple with a type of entity ('table', 'column' etc) and a scope. A scope for a column category will be a list of tables. """ word_before_cursor = last_word(text_before_cursor, include="many_punctuations") identifier: Identifier | None = None # here should be removed once sqlparse has been fixed try: # If we've partially typed a word then word_before_cursor won't be an empty # string. In that case we want to remove the partially typed string before # sending it to the sqlparser. Otherwise the last token will always be the # partially typed string which renders the smart completion useless because # it will always return the list of keywords as completion. if word_before_cursor: if word_before_cursor.endswith("(") or word_before_cursor.startswith("\\"): parsed = sqlparse.parse(text_before_cursor) else: parsed = sqlparse.parse(text_before_cursor[: -len(word_before_cursor)]) # word_before_cursor may include a schema qualification, like # "schema_name.partial_name" or "schema_name.", so parse it # separately p = sqlparse.parse(word_before_cursor)[0] if p.tokens and isinstance(p.tokens[0], Identifier): identifier = p.tokens[0] else: parsed = sqlparse.parse(text_before_cursor) except (TypeError, AttributeError): return [{"type": "keyword"}] if len(parsed) > 1: # Multiple statements being edited -- isolate the current one by # cumulatively summing statement lengths to find the one that bounds the # current position current_pos = len(text_before_cursor) stmt_start, stmt_end = 0, 0 for statement in parsed: stmt_len = len(str(statement)) stmt_start, stmt_end = stmt_end, stmt_end + stmt_len if stmt_end >= current_pos: text_before_cursor = full_text[stmt_start:current_pos] full_text = full_text[stmt_start:] break elif parsed: # A single statement statement = parsed[0] else: # The empty string statement = None # Check for special commands and handle those separately if statement: # Be careful here because trivial whitespace is parsed as a statement, # but the statement won't have a first token tok1 = statement.token_first() if tok1 and (tok1.value == "source" or tok1.value.startswith("\\")): return suggest_special(text_before_cursor) last_token = statement and statement.token_prev(len(statement.tokens))[1] or "" return suggest_based_on_last_token(last_token, text_before_cursor, full_text, identifier) def suggest_special(text: str) -> list[dict[str, Any]]: text = text.lstrip() cmd, _separator, _arg = parse_special_command(text) if cmd == text: # Trying to complete the special command itself return [{"type": "special"}] if cmd in ("\\u", "\\r"): return [{"type": "database"}] if cmd in ("\\T"): return [{"type": "table_format"}] if cmd in ["\\f", "\\fs", "\\fd"]: return [{"type": "favoritequery"}] if cmd in ["\\dt", "\\dt+"]: return [ {"type": "table", "schema": []}, {"type": "view", "schema": []}, {"type": "schema"}, ] elif cmd in ["\\.", "source"]: return [{"type": "file_name"}] if cmd in ["\\llm", "\\ai"]: return [{"type": "llm"}] return [{"type": "keyword"}, {"type": "special"}] def suggest_based_on_last_token( token: str | Token | None, text_before_cursor: str, full_text: str, identifier: Identifier, ) -> list[dict[str, Any]]: if isinstance(token, str): token_v = token.lower() elif isinstance(token, Comparison): # If 'token' is a Comparison type such as # 'select * FROM abc a JOIN def d ON a.id = d.'. Then calling # token.value on the comparison type will only return the lhs of the # comparison. In this case a.id. So we need to do token.tokens to get # both sides of the comparison and pick the last token out of that # list. token_v = token.tokens[-1].value.lower() elif isinstance(token, Where): # sqlparse groups all tokens from the where clause into a single token # list. This means that token.value may be something like # 'where foo > 5 and '. We need to look "inside" token.tokens to handle # suggestions in complicated where clauses correctly prev_keyword, text_before_cursor = find_prev_keyword(text_before_cursor) return suggest_based_on_last_token(prev_keyword, text_before_cursor, full_text, identifier) elif token is None: return [{"type": "keyword"}] else: token_v = token.value.lower() is_operand = lambda x: x and any(x.endswith(op) for op in ["+", "-", "*", "/"]) # noqa: E731 if not token: return [{"type": "keyword"}, {"type": "special"}] elif token_v == "*": return [{"type": "keyword"}] elif token_v.endswith("("): p = sqlparse.parse(text_before_cursor)[0] if p.tokens and isinstance(p.tokens[-1], Where): # Four possibilities: # 1 - Parenthesized clause like "WHERE foo AND (" # Suggest columns/functions # 2 - Function call like "WHERE foo(" # Suggest columns/functions # 3 - Subquery expression like "WHERE EXISTS (" # Suggest keywords, in order to do a subquery # 4 - Subquery OR array comparison like "WHERE foo = ANY(" # Suggest columns/functions AND keywords. (If we wanted to be # really fancy, we could suggest only array-typed columns) column_suggestions = suggest_based_on_last_token("where", text_before_cursor, full_text, identifier) # Check for a subquery expression (cases 3 & 4) where = p.tokens[-1] _idx, prev_tok = where.token_prev(len(where.tokens) - 1) if isinstance(prev_tok, Comparison): # e.g. "SELECT foo FROM bar WHERE foo = ANY(" prev_tok = prev_tok.tokens[-1] prev_tok = prev_tok.value.lower() if prev_tok == "exists": return [{"type": "keyword"}] else: return column_suggestions # Get the token before the parens idx, prev_tok = p.token_prev(len(p.tokens) - 1) if prev_tok and prev_tok.value and prev_tok.value.lower() == "using": # tbl1 INNER JOIN tbl2 USING (col1, col2) tables = extract_tables(full_text) # suggest columns that are present in more than one table return [{"type": "column", "tables": tables, "drop_unique": True}] elif p.token_first().value.lower() == "select": # If the lparen is preceeded by a space chances are we're about to # do a sub-select. if last_word(text_before_cursor, "all_punctuations").startswith("("): return [{"type": "keyword"}] elif p.token_first().value.lower() == "show": return [{"type": "show"}] # We're probably in a function argument list return [{"type": "column", "tables": extract_tables(full_text)}] elif token_v in ("set", "order by", "distinct"): return [{"type": "column", "tables": extract_tables(full_text)}] elif token_v == "as": # Don't suggest anything for an alias return [] elif token_v in ("show"): return [{"type": "show"}] elif token_v in ("to",): p = sqlparse.parse(text_before_cursor)[0] if p.token_first().value.lower() == "change": return [{"type": "change"}] else: return [{"type": "user"}] elif token_v in ("user", "for"): return [{"type": "user"}] elif token_v in ("select", "where", "having"): # Check for a table alias or schema qualification parent = (identifier and identifier.get_parent_name()) or [] tables = extract_tables(full_text) if parent: tables = [t for t in tables if identifies(parent, *t)] return [ {"type": "column", "tables": tables}, {"type": "table", "schema": parent}, {"type": "view", "schema": parent}, {"type": "function", "schema": parent}, ] else: aliases = [alias or table for (schema, table, alias) in tables] return [ {"type": "column", "tables": tables}, {"type": "function", "schema": []}, {"type": "alias", "aliases": aliases}, {"type": "keyword"}, ] elif (token_v.endswith("join") and isinstance(token, Token) and token.is_keyword) or ( token_v in ("copy", "from", "update", "into", "describe", "truncate", "desc", "explain") ): schema = (identifier and identifier.get_parent_name()) or [] # Suggest tables from either the currently-selected schema or the # public schema if no schema has been specified suggest = [{"type": "table", "schema": schema}] if not schema: # Suggest schemas suggest.insert(0, {"type": "schema"}) # Only tables can be TRUNCATED, otherwise suggest views if token_v != "truncate": suggest.append({"type": "view", "schema": schema}) return suggest elif token_v in ("table", "view", "function"): # E.g. 'DROP FUNCTION ', 'ALTER TABLE ' rel_type = token_v schema = (identifier and identifier.get_parent_name()) or [] if schema: return [{"type": rel_type, "schema": schema}] else: return [{"type": "schema"}, {"type": rel_type, "schema": []}] elif token_v == "on": tables = extract_tables(full_text) # [(schema, table, alias), ...] parent = (identifier and identifier.get_parent_name()) or [] if parent: # "ON parent." # parent can be either a schema name or table alias tables = [t for t in tables if identifies(parent, *t)] return [ {"type": "column", "tables": tables}, {"type": "table", "schema": parent}, {"type": "view", "schema": parent}, {"type": "function", "schema": parent}, ] else: # ON # Use table alias if there is one, otherwise the table name aliases = [alias or table for (schema, table, alias) in tables] suggest = [{"type": "alias", "aliases": aliases}] # The lists of 'aliases' could be empty if we're trying to complete # a GRANT query. eg: GRANT SELECT, INSERT ON # In that case we just suggest all tables. if not aliases: suggest.append({"type": "table", "schema": parent}) return suggest elif token_v in ("use", "database", "template", "connect"): # "\c ", "DROP DATABASE ", # "CREATE DATABASE WITH TEMPLATE " return [{"type": "database"}] elif token_v == "tableformat": return [{"type": "table_format"}] elif token_v.endswith(",") or is_operand(token_v) or token_v in ["=", "and", "or"]: prev_keyword, text_before_cursor = find_prev_keyword(text_before_cursor) if prev_keyword: return suggest_based_on_last_token(prev_keyword, text_before_cursor, full_text, identifier) else: return [] else: return [{"type": "keyword"}] def identifies( identifier: Any, schema: str | None, table: str, alias: str, ) -> bool: if identifier == alias: return True if identifier == table: return True if schema and identifier == (schema + "." + table): return True return False ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/packages/filepaths.py0000644000175100017510000000565515101406164017615 0ustar00runnerrunnerimport os import platform DEFAULT_SOCKET_DIRS: list[str] = [] if os.name == "posix": if platform.system() == "Darwin": DEFAULT_SOCKET_DIRS = ["/tmp"] else: DEFAULT_SOCKET_DIRS = ["/var/run", "/var/lib"] def list_path(root_dir: str) -> list[str]: """List directory if exists. :param root_dir: str :return: list """ res = [] if os.path.isdir(root_dir): for name in os.listdir(root_dir): res.append(name) return res def complete_path(curr_dir: str, last_dir: str) -> str: """Return the path to complete that matches the last entered component. If the last entered component is ~, expanded path would not match, so return all of the available paths. :param curr_dir: str :param last_dir: str :return: str """ if not last_dir or curr_dir.startswith(last_dir): return curr_dir elif last_dir == "~": return os.path.join(last_dir, curr_dir) else: return '' def parse_path(root_dir: str) -> tuple[str, str, int]: """Split path into head and last component for the completer. Also return position where last component starts. :param root_dir: str path :return: tuple of (string, string, int) """ base_dir, last_dir, position = "", "", 0 if root_dir: base_dir, last_dir = os.path.split(root_dir) position = -len(last_dir) if last_dir else 0 return base_dir, last_dir, position def suggest_path(root_dir: str) -> list[str]: """List all files and subdirectories in a directory. If the directory is not specified, suggest root directory, user directory, current and parent directory. :param root_dir: string: directory to list :return: list """ if not root_dir: return [os.path.abspath(os.sep), "~", os.curdir, os.pardir] if "~" in root_dir: root_dir = os.path.expanduser(root_dir) if not os.path.exists(root_dir): root_dir, _ = os.path.split(root_dir) return list_path(root_dir) def dir_path_exists(path: str) -> bool: """Check if the directory path exists for a given file. For example, for a file /home/user/.cache/mycli/log, check if /home/user/.cache/mycli exists. :param str path: The file path. :return: Whether or not the directory path exists. """ return os.path.exists(os.path.dirname(path)) def guess_socket_location() -> str | None: """Try to guess the location of the default mysql socket file.""" socket_dirs = filter(os.path.exists, DEFAULT_SOCKET_DIRS) for directory in socket_dirs: for r, dirs, files in os.walk(directory, topdown=True): for filename in files: name, ext = os.path.splitext(filename) if name.startswith("mysql") and name != "mysqlx" and ext in (".socket", ".sock"): return os.path.join(r, filename) dirs[:] = [d for d in dirs if d.startswith("mysql")] return None ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/packages/hybrid_redirection.py0000644000175100017510000001367715101406164021511 0ustar00runnerrunnerimport functools import logging import sqlglot from mycli.compat import WIN from mycli.packages.special.delimitercommand import DelimiterCommand logger = logging.getLogger(__name__) delimiter_command = DelimiterCommand() def find_token_indices(tokens: list[sqlglot.Token]) -> dict[str, list[int]]: token_indices: dict[str, list[int]] = { 'raw_dollar': [], 'true_dollar': [], 'angle_bracket': [], 'pipe': [], } for i, tok in enumerate(tokens): if tok.token_type == sqlglot.TokenType.VAR and tok.text == '$': token_indices['raw_dollar'].append(i) continue if tok.token_type == sqlglot.TokenType.GT and (i - 1) in token_indices['raw_dollar']: token_indices['angle_bracket'].append(i) continue if tok.token_type == sqlglot.TokenType.PIPE and (i - 1) in token_indices['raw_dollar']: token_indices['pipe'].append(i) continue for i in token_indices['raw_dollar']: if (i + 1) in token_indices['angle_bracket'] or (i + 1) in token_indices['pipe']: token_indices['true_dollar'].append(i) return token_indices def find_sql_part( command: str, tokens: list[sqlglot.Token], true_dollar_indices: list[int], ): leftmost_dollar_pos = tokens[true_dollar_indices[0]].start sql_part = command[0:leftmost_dollar_pos].strip().removesuffix(delimiter_command.current).rstrip() try: statements = sqlglot.parse(sql_part, read='mysql') except sqlglot.errors.ParseError: return '' if len(statements) != 1: # buglet: the statement count doesn't respect a custom delimiter return '' return sql_part def find_command_tokens( tokens: list[sqlglot.Token], true_dollar_indices: list[int], ) -> list[sqlglot.Token]: command_part_tokens = [] for i, tok in enumerate(tokens): if i < true_dollar_indices[0]: continue if i in true_dollar_indices: continue command_part_tokens.append(tok) if command_part_tokens: _operator = command_part_tokens.pop(0) return command_part_tokens def find_file_tokens( tokens: list[sqlglot.Token], angle_bracket_indices: list[int], ) -> tuple[list[sqlglot.Token], int, str | None]: file_part_tokens: list[sqlglot.Token] = [] file_part_index = len(tokens) if not angle_bracket_indices: return file_part_tokens, file_part_index, None file_part_tokens = tokens[angle_bracket_indices[-1] :] file_part_index = angle_bracket_indices[-1] file_operator_part = file_part_tokens.pop(0).text if file_operator_part == '>' and file_part_tokens[0].token_type == sqlglot.TokenType.GT: file_part_tokens.pop(0) file_operator_part = '>>' return file_part_tokens, file_part_index, file_operator_part def assemble_tokens(tokens: list[sqlglot.Token]) -> str: assembled_string = ' ' * (tokens[-1].end + 10) for tok in tokens: if tok.token_type == sqlglot.TokenType.IDENTIFIER: text = f'"{tok.text}"' offset = 2 elif tok.token_type == sqlglot.TokenType.STRING: text = f"'{tok.text}'" offset = 2 else: text = tok.text offset = 0 assembled_string = assembled_string[0 : tok.start] + text + assembled_string[tok.end + offset :] return assembled_string.strip().removesuffix(delimiter_command.current).rstrip() def invalid_shell_part( file_part: str | None, command_part: str | None, ) -> bool: if file_part and ' ' in file_part: return True if file_part and '>' in file_part: return True if not file_part and not command_part: return True return False @functools.lru_cache(maxsize=1) def get_redirect_components(command: str) -> tuple[str | None, str | None, str | None, str | None]: """Get the parts of a hybrid shell-style redirect command.""" try: tokens = sqlglot.tokenize(command) except sqlglot.errors.TokenError: return None, None, None, None token_indices = find_token_indices(tokens) if not token_indices['true_dollar']: return None, None, None, None if len(token_indices['angle_bracket']) > 1: return None, None, None, None if WIN and len(token_indices['pipe']) > 1: # how to give better feedback here? return None, None, None, None if token_indices['angle_bracket'] and token_indices['pipe']: if token_indices['pipe'][-1] > token_indices['angle_bracket'][-1]: return None, None, None, None sql_part = find_sql_part( command, tokens, token_indices['true_dollar'], ) if not sql_part: return None, None, None, None ( file_part_tokens, file_part_index, file_operator_part, ) = find_file_tokens( tokens, token_indices['angle_bracket'], ) command_part_tokens = find_command_tokens( tokens[0:file_part_index], token_indices['true_dollar'], ) if file_part_tokens: file_part = assemble_tokens(file_part_tokens) else: file_part = None if command_part_tokens: command_part = assemble_tokens(command_part_tokens) else: command_part = None if invalid_shell_part(file_part, command_part): return None, None, None, None logger.debug('redirect parse sql_part: "{}"'.format(sql_part)) logger.debug('redirect parse command_part: "{}"'.format(command_part)) logger.debug('redirect parse file_operator_part: "{}"'.format(file_operator_part)) logger.debug('redirect parse file_part: "{}"'.format(file_part)) return sql_part, command_part, file_operator_part, file_part def is_redirect_command(command: str) -> bool: """Is this a shell-style redirect to command or file? :param command: string """ sql_part, _command_part, _file_operator_part, _file_part = get_redirect_components(command) return bool(sql_part) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1762004092.2868173 mycli-1.41.0/mycli/packages/paramiko_stub/0000755000175100017510000000000015101406174020112 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/packages/paramiko_stub/__init__.py0000644000175100017510000000156215101406164022226 0ustar00runnerrunner"""A module to import instead of paramiko when it is not available (to avoid checking for paramiko all over the place). When paramiko is first invoked, this simply shuts down mycli, telling the user they either have to install paramiko or should not use SSH features. """ class Paramiko: def __getattr__(self, name: str) -> None: import sys from textwrap import dedent print( dedent(""" To enable certain SSH features you need to install ssh extras: pip install 'mycli[ssh]' or pip install paramiko sshtunnel This is required for the following command-line arguments: --list-ssh-config --ssh-config-host --ssh-host """), file=sys.stderr, ) sys.exit(1) paramiko = Paramiko() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/packages/parseutils.py0000644000175100017510000002606115101406164020023 0ustar00runnerrunnerfrom __future__ import annotations import re from typing import Generator import sqlglot import sqlparse from sqlparse.sql import Function, Identifier, IdentifierList, Token, TokenList from sqlparse.tokens import DML, Keyword, Punctuation cleanup_regex: dict[str, re.Pattern] = { # This matches only alphanumerics and underscores. "alphanum_underscore": re.compile(r"(\w+)$"), # This matches everything except spaces, parens, colon, and comma "many_punctuations": re.compile(r"([^():,\s]+)$"), # This matches everything except spaces, parens, colon, comma, and period "most_punctuations": re.compile(r"([^\.():,\s]+)$"), # This matches everything except a space. "all_punctuations": re.compile(r"([^\s]+)$"), } def last_word(text: str, include: str = "alphanum_underscore") -> str: r""" Find the last word in a sentence. >>> last_word('abc') 'abc' >>> last_word(' abc') 'abc' >>> last_word('') '' >>> last_word(' ') '' >>> last_word('abc ') '' >>> last_word('abc def') 'def' >>> last_word('abc def ') '' >>> last_word('abc def;') '' >>> last_word('bac $def') 'def' >>> last_word('bac $def', include='most_punctuations') '$def' >>> last_word('bac \def', include='most_punctuations') '\\\\def' >>> last_word('bac \def;', include='most_punctuations') '\\\\def;' >>> last_word('bac::def', include='most_punctuations') 'def' """ if not text: # Empty string return "" if text[-1].isspace(): return "" else: regex = cleanup_regex[include] matches = regex.search(text) if matches: return matches.group(0) else: return "" # This code is borrowed from sqlparse example script. # def is_subselect(parsed: TokenList) -> bool: if not parsed.is_group: return False for item in parsed.tokens: if item.ttype is DML and item.value.upper() in ("SELECT", "INSERT", "UPDATE", "CREATE", "DELETE"): return True return False def extract_from_part(parsed: TokenList, stop_at_punctuation: bool = True) -> Generator[str, None, None]: tbl_prefix_seen = False for item in parsed.tokens: if tbl_prefix_seen: if is_subselect(item): for x in extract_from_part(item, stop_at_punctuation): yield x elif stop_at_punctuation and item.ttype is Punctuation: return None # Multiple JOINs in the same query won't work properly since # "ON" is a keyword and will trigger the next elif condition. # So instead of stooping the loop when finding an "ON" skip it # eg: 'SELECT * FROM abc JOIN def ON abc.id = def.abc_id JOIN ghi' elif item.ttype is Keyword and item.value.upper() == "ON": tbl_prefix_seen = False continue # An incomplete nested select won't be recognized correctly as a # sub-select. eg: 'SELECT * FROM (SELECT id FROM user'. This causes # the second FROM to trigger this elif condition resulting in a # StopIteration. So we need to ignore the keyword if the keyword # FROM. # Also 'SELECT * FROM abc JOIN def' will trigger this elif # condition. So we need to ignore the keyword JOIN and its variants # INNER JOIN, FULL OUTER JOIN, etc. elif item.ttype is Keyword and (not item.value.upper() == "FROM") and (not item.value.upper().endswith("JOIN")): return None else: yield item elif (item.ttype is Keyword or item.ttype is Keyword.DML) and item.value.upper() in ( "COPY", "FROM", "INTO", "UPDATE", "TABLE", "JOIN", ): tbl_prefix_seen = True # 'SELECT a, FROM abc' will detect FROM as part of the column list. # So this check here is necessary. elif isinstance(item, IdentifierList): for identifier in item.get_identifiers(): if identifier.ttype is Keyword and identifier.value.upper() == "FROM": tbl_prefix_seen = True break def extract_table_identifiers(token_stream: TokenList) -> Generator[tuple[str | None, str, str], None, None]: """yields tuples of (schema_name, table_name, table_alias)""" for item in token_stream: if isinstance(item, IdentifierList): for identifier in item.get_identifiers(): # Sometimes Keywords (such as FROM ) are classified as # identifiers which don't have the get_real_name() method. try: schema_name = identifier.get_parent_name() real_name = identifier.get_real_name() except AttributeError: continue if real_name: yield (schema_name, real_name, identifier.get_alias()) elif isinstance(item, Identifier): real_name = item.get_real_name() schema_name = item.get_parent_name() if real_name: yield (schema_name, real_name, item.get_alias()) else: name = item.get_name() yield (None, name, item.get_alias() or name) elif isinstance(item, Function): yield (None, item.get_name(), item.get_name()) # extract_tables is inspired from examples in the sqlparse lib. def extract_tables(sql: str) -> list[tuple[str | None, str, str]]: """Extract the table names from an SQL statement. Returns a list of (schema, table, alias) tuples """ parsed = sqlparse.parse(sql) if not parsed: return [] # INSERT statements must stop looking for tables at the sign of first # Punctuation. eg: INSERT INTO abc (col1, col2) VALUES (1, 2) # abc is the table name, but if we don't stop at the first lparen, then # we'll identify abc, col1 and col2 as table names. insert_stmt = parsed[0].token_first().value.lower() == "insert" stream = extract_from_part(parsed[0], stop_at_punctuation=insert_stmt) return list(extract_table_identifiers(stream)) def extract_tables_from_complete_statements(sql: str) -> list[tuple[str | None, str, str | None]]: """Extract the table names from a complete and valid series of SQL statements. Returns a list of (schema, table, alias) tuples """ # sqlglot chokes entirely on things like "\T" that it doesn't know about, # but is much better at extracting table names from complete statements. # sqlparse can extract the series of statements, though it also doesn't # understand "\T". roughly_parsed = sqlparse.parse(sql) if not roughly_parsed: return [] finely_parsed = [] for statement in roughly_parsed: try: finely_parsed.append(sqlglot.parse_one(str(statement), read='mysql')) except sqlglot.errors.ParseError: pass tables = [] for statement in finely_parsed: for identifier in statement.find_all(sqlglot.exp.Table): if identifier.parent_select and identifier.parent_select.sql().startswith('WITH'): continue tables.append(( None if identifier.db == '' else identifier.db, identifier.name, None if identifier.alias == '' else identifier.alias, )) return tables def find_prev_keyword(sql: str) -> tuple[Token | None, str]: """Find the last sql keyword in an SQL statement Returns the value of the last keyword, and the text of the query with everything after the last keyword stripped """ if not sql.strip(): return None, "" parsed = sqlparse.parse(sql)[0] flattened = list(parsed.flatten()) logical_operators = ("AND", "OR", "NOT", "BETWEEN") for t in reversed(flattened): if t.value == "(" or (t.is_keyword and (t.value.upper() not in logical_operators)): # Find the location of token t in the original parsed statement # We can't use parsed.token_index(t) because t may be a child token # inside a TokenList, in which case token_index thows an error # Minimal example: # p = sqlparse.parse('select * from foo where bar') # t = list(p.flatten())[-3] # The "Where" token # p.token_index(t) # Throws ValueError: not in list idx = flattened.index(t) # Combine the string values of all tokens in the original list # up to and including the target keyword token t, to produce a # query string with everything after the keyword token removed text = "".join(tok.value for tok in flattened[: idx + 1]) return t, text return None, "" def query_starts_with(query: str, prefixes: list[str]) -> bool: """Check if the query starts with any item from *prefixes*.""" prefixes = [prefix.lower() for prefix in prefixes] formatted_sql = sqlparse.format(query.lower(), strip_comments=True) return bool(formatted_sql) and formatted_sql.split()[0] in prefixes def queries_start_with(queries: str, prefixes: list[str]) -> bool: """Check if any queries start with any item from *prefixes*.""" for query in sqlparse.split(queries): if query and query_starts_with(query, prefixes) is True: return True return False def query_has_where_clause(query: str) -> bool: """Check if the query contains a where-clause.""" return any(isinstance(token, sqlparse.sql.Where) for token_list in sqlparse.parse(query) for token in token_list) def is_destructive(queries: str) -> bool: """Returns if any of the queries in *queries* is destructive.""" keywords = ("drop", "shutdown", "delete", "truncate", "alter") for query in sqlparse.split(queries): if query: if query_starts_with(query, list(keywords)) is True: return True elif query_starts_with(query, ["update"]) is True and not query_has_where_clause(query): return True return False def is_dropping_database(queries: str, dbname: str | None) -> bool: """Determine if the query is dropping a specific database.""" result = False if dbname is None: return False def normalize_db_name(db: str) -> str: return db.lower().strip('`"') dbname = normalize_db_name(dbname) for query in sqlparse.parse(queries): keywords = [t for t in query.tokens if t.is_keyword] if len(keywords) < 2: continue if keywords[0].normalized in ("DROP", "CREATE") and keywords[1].value.lower() in ( "database", "schema", ): database_token = next((t for t in query.tokens if isinstance(t, Identifier)), None) if database_token is not None and normalize_db_name(database_token.get_name()) == dbname: result = keywords[0].normalized == "DROP" return result if __name__ == "__main__": sql = "select * from (select t. from tabl t" print(extract_tables(sql)) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/packages/prompt_utils.py0000644000175100017510000000317515101406164020372 0ustar00runnerrunnerimport sys import click from mycli.packages.parseutils import is_destructive class ConfirmBoolParamType(click.ParamType): name = "confirmation" def convert(self, value: bool | str, param: click.Parameter | None, ctx: click.Context | None) -> bool: if isinstance(value, bool): return bool(value) value = value.lower() if value in ("yes", "y"): return True if value in ("no", "n"): return False self.fail(f'{value} is not a valid boolean', param, ctx) def __repr__(self): return "BOOL" BOOLEAN_TYPE = ConfirmBoolParamType() def confirm_destructive_query(queries: str) -> bool | None: """Check if the query is destructive and prompts the user to confirm. Returns: * None if the query is non-destructive or we can't prompt the user. * True if the query is destructive and the user wants to proceed. * False if the query is destructive and the user doesn't want to proceed. """ prompt_text = "You're about to run a destructive command.\nDo you want to proceed? (y/n)" if is_destructive(queries) and sys.stdin.isatty(): return prompt(prompt_text, type=BOOLEAN_TYPE) else: return None def confirm(*args, **kwargs) -> bool: """Prompt for confirmation (yes/no) and handle any abort exceptions.""" try: return click.confirm(*args, **kwargs) except click.Abort: return False def prompt(*args, **kwargs) -> bool: """Prompt the user for input and handle any abort exceptions.""" try: return click.prompt(*args, **kwargs) except click.Abort: return False ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/packages/shortcuts.py0000644000175100017510000000100515101406164017655 0ustar00runnerrunnerfrom mycli.sqlexecute import SQLExecute def server_date(sqlexecute: SQLExecute, quoted: bool = False) -> str: server_date_str = sqlexecute.now().strftime('%Y-%m-%d') if quoted: return f"'{server_date_str}'" else: return server_date_str def server_datetime(sqlexecute: SQLExecute, quoted: bool = False) -> str: server_datetime_str = sqlexecute.now().strftime('%Y-%m-%d %H:%M:%S') if quoted: return f"'{server_datetime_str}'" else: return server_datetime_str ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1762004092.2888172 mycli-1.41.0/mycli/packages/special/0000755000175100017510000000000015101406174016672 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/packages/special/__init__.py0000644000175100017510000000377715101406164021020 0ustar00runnerrunnerfrom mycli.packages.special.dbcommands import ( list_databases, list_tables, status, ) from mycli.packages.special.iocommands import ( clip_command, close_tee, copy_query_to_clipboard, disable_pager, editor_command, flush_pipe_once_if_written, forced_horizontal, get_clip_query, get_current_delimiter, get_editor_query, get_filename, is_expanded_output, is_pager_enabled, is_redirected, is_timing_enabled, open_external_editor, set_delimiter, set_expanded_output, set_favorite_queries, set_forced_horizontal_output, set_pager, set_pager_enabled, set_redirect, set_timing_enabled, split_queries, unset_once_if_written, write_once, write_pipe_once, write_tee, ) from mycli.packages.special.llm import ( FinishIteration, handle_llm, is_llm_command, sql_using_llm, ) from mycli.packages.special.main import ( CommandNotFound, execute, parse_special_command, register_special_command, special_command, ) __all__: list[str] = [ 'CommandNotFound', 'FinishIteration', 'clip_command', 'close_tee', 'copy_query_to_clipboard', 'disable_pager', 'editor_command', 'execute', 'flush_pipe_once_if_written', 'forced_horizontal', 'get_clip_query', 'get_current_delimiter', 'get_editor_query', 'get_filename', 'handle_llm', 'is_expanded_output', 'is_llm_command', 'is_pager_enabled', 'is_redirected', 'is_timing_enabled', 'list_databases', 'list_tables', 'open_external_editor', 'parse_special_command', 'register_special_command', 'set_delimiter', 'set_expanded_output', 'set_favorite_queries', 'set_forced_horizontal_output', 'set_pager', 'set_pager_enabled', 'set_redirect', 'set_timing_enabled', 'special_command', 'split_queries', 'sql_using_llm', 'status', 'unset_once_if_written', 'write_once', 'write_pipe_once', 'write_tee', ] ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/packages/special/dbcommands.py0000644000175100017510000001301315101406164021350 0ustar00runnerrunnerimport logging import os import platform from pymysql import ProgrammingError from pymysql.cursors import Cursor from mycli import __version__ from mycli.packages.special import iocommands from mycli.packages.special.main import ArgType, special_command from mycli.packages.special.utils import format_uptime logger = logging.getLogger(__name__) @special_command("\\dt", "\\dt[+] [table]", "List or describe tables.", arg_type=ArgType.PARSED_QUERY, case_sensitive=True) def list_tables( cur: Cursor, arg: str | None = None, _arg_type: ArgType = ArgType.PARSED_QUERY, verbose: bool = False, ) -> list[tuple]: if arg: query = f'SHOW FIELDS FROM {arg}' else: query = "SHOW TABLES" logger.debug(query) cur.execute(query) tables = cur.fetchall() status = "" if cur.description: headers = [x[0] for x in cur.description] else: return [(None, None, None, "")] if verbose and arg: query = f'SHOW CREATE TABLE {arg}' logger.debug(query) cur.execute(query) if one := cur.fetchone(): status = one[1] return [(None, tables, headers, status)] @special_command("\\l", "\\l", "List databases.", arg_type=ArgType.RAW_QUERY, case_sensitive=True) def list_databases(cur: Cursor, **_) -> list[tuple]: query = "SHOW DATABASES" logger.debug(query) cur.execute(query) if cur.description: headers = [x[0] for x in cur.description] return [(None, cur, headers, "")] else: return [(None, None, None, "")] @special_command( "status", "\\s", "Get status information from the server.", arg_type=ArgType.RAW_QUERY, aliases=["\\s"], case_sensitive=True ) def status(cur: Cursor, **_) -> list[tuple]: query = "SHOW GLOBAL STATUS;" logger.debug(query) try: cur.execute(query) except ProgrammingError: # Fallback in case query fail, as it does with Mysql 4 query = "SHOW STATUS;" logger.debug(query) cur.execute(query) status = dict(cur.fetchall()) query = "SHOW GLOBAL VARIABLES;" logger.debug(query) cur.execute(query) variables = dict(cur.fetchall()) # prepare in case keys are bytes, as with Python 3 and Mysql 4 if isinstance(list(variables)[0], bytes) and isinstance(list(status)[0], bytes): variables = {k.decode("utf-8"): v.decode("utf-8") for k, v in variables.items()} status = {k.decode("utf-8"): v.decode("utf-8") for k, v in status.items()} # Create output buffers. title = [] output = [] footer = [] title.append("--------------") # Output the mycli client information. implementation = platform.python_implementation() version = platform.python_version() client_info = [] client_info.append(f'mycli {__version__}') client_info.append(f'running on {implementation} {version}') title.append(" ".join(client_info) + "\n") # Build the output that will be displayed as a table. output.append(("Connection id:", cur.connection.thread_id())) query = "SELECT DATABASE(), USER();" logger.debug(query) cur.execute(query) if one := cur.fetchone(): db, user = one else: db = "" user = "" output.append(("Current database:", db)) output.append(("Current user:", user)) if iocommands.is_pager_enabled(): if "PAGER" in os.environ: pager = os.environ["PAGER"] else: pager = "System default" else: pager = "stdout" output.append(("Current pager:", pager)) output.append(("Server version:", f'{variables["version"]} {variables["version_comment"]}')) output.append(("Protocol version:", variables["protocol_version"])) if "unix" in cur.connection.host_info.lower(): host_info = cur.connection.host_info else: host_info = f'{cur.connection.host} via TCP/IP' output.append(("Connection:", host_info)) query = "SELECT @@character_set_server, @@character_set_database, @@character_set_client, @@character_set_connection LIMIT 1;" logger.debug(query) cur.execute(query) if one := cur.fetchone(): charset = one else: charset = ("", "", "", "") output.append(("Server characterset:", charset[0])) output.append(("Db characterset:", charset[1])) output.append(("Client characterset:", charset[2])) output.append(("Conn. characterset:", charset[3])) if "TCP/IP" in host_info: output.append(("TCP port:", cur.connection.port)) else: output.append(("UNIX socket:", variables["socket"])) if "Uptime" in status: output.append(("Uptime:", format_uptime(status["Uptime"]))) if "Threads_connected" in status: # Print the current server statistics. stats = [] stats.append(f'Connections: {status["Threads_connected"]}') if "Queries" in status: stats.append(f'Queries: {status["Queries"]}') stats.append(f'Slow queries: {status["Slow_queries"]}') stats.append(f'Opens: {status["Opened_tables"]}') if "Flush_commands" in status: stats.append(f'Flush tables: {status["Flush_commands"]}') stats.append(f'Open tables: {status["Open_tables"]}') if "Queries" in status: queries_per_second = int(status["Queries"]) / int(status["Uptime"]) stats.append(f'Queries per second avg: {queries_per_second:.3f}') stats_str = " ".join(stats) footer.append("\n" + stats_str) footer.append("--------------") return [("\n".join(title), output, "", "\n".join(footer))] ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/packages/special/delimitercommand.py0000644000175100017510000000535315101406164022566 0ustar00runnerrunnerfrom __future__ import annotations import re from typing import Generator import sqlparse class DelimiterCommand: def __init__(self) -> None: self._delimiter = ";" def _split(self, sql: str) -> list[str]: """Temporary workaround until sqlparse.split() learns about custom delimiters.""" placeholder = "\ufffc" # unicode object replacement character if self._delimiter == ";": return sqlparse.split(sql) # We must find a string that original sql does not contain. # Most likely, our placeholder is enough, but if not, keep looking while placeholder in sql: placeholder += placeholder[0] sql = sql.replace(";", placeholder) sql = sql.replace(self._delimiter, ";") split = sqlparse.split(sql) return [stmt.replace(";", self._delimiter).replace(placeholder, ";") for stmt in split] def queries_iter(self, input_str: str) -> Generator[str, None, None]: """Iterate over queries in the input string.""" queries = self._split(input_str) while queries: for sql in queries: delimiter = self._delimiter sql = queries.pop(0) if sql.endswith(delimiter): trailing_delimiter = True sql = sql.strip(delimiter) else: trailing_delimiter = False yield sql # if the delimiter was changed by the last command, # re-split everything, and if we previously stripped # the delimiter, append it to the end if self._delimiter != delimiter: combined_statement = " ".join([sql] + queries) if trailing_delimiter: combined_statement += delimiter queries = self._split(combined_statement)[1:] def set(self, arg: str, **_) -> list[tuple[None, None, None, str]]: """Change delimiter. Since `arg` is everything that follows the DELIMITER token after sqlparse (it may include other statements separated by the new delimiter), we want to set the delimiter to the first word of it. """ match = arg and re.search(r"[^\s]+", arg) if not match: message = "Missing required argument, delimiter" return [(None, None, None, message)] delimiter = match.group() if delimiter.lower() == "delimiter": return [(None, None, None, 'Invalid delimiter "delimiter"')] self._delimiter = delimiter return [(None, None, None, f'Changed delimiter to {delimiter}')] @property def current(self) -> str: return self._delimiter ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/packages/special/favoritequeries.py0000644000175100017510000000434215101406164022463 0ustar00runnerrunnerfrom __future__ import annotations class FavoriteQueries: section_name: str = "favorite_queries" usage = """ Favorite Queries are a way to save frequently used queries with a short name. Examples: # Save a new favorite query. > \\fs simple select * from abc where a is not Null; # List all favorite queries. > \\f ╒════════╤═══════════════════════════════════════╕ │ Name │ Query │ ╞════════╪═══════════════════════════════════════╡ │ simple │ SELECT * FROM abc where a is not NULL │ ╘════════╧═══════════════════════════════════════╛ # Run a favorite query. > \\f simple ╒════════╤════════╕ │ a │ b │ ╞════════╪════════╡ │ 日本語 │ 日本語 │ ╘════════╧════════╛ # Delete a favorite query. > \\fd simple simple: Deleted. """ # Class-level variable, for convenience to use as a singleton. instance: FavoriteQueries def __init__(self, config) -> None: self.config = config @classmethod def from_config(cls, config): return FavoriteQueries(config) def list(self) -> list[str | None]: return self.config.get(self.section_name, []) def get(self, name) -> str | None: return self.config.get(self.section_name, {}).get(name, None) def save(self, name: str, query: str) -> None: self.config.encoding = "utf-8" if self.section_name not in self.config: self.config[self.section_name] = {} self.config[self.section_name][name] = query self.config.write() def delete(self, name: str) -> str: try: del self.config[self.section_name][name] except KeyError: return f'{name}: Not Found.' self.config.write() return f'{name}: Deleted.' ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/packages/special/iocommands.py0000644000175100017510000004410415101406164021377 0ustar00runnerrunnerfrom __future__ import annotations import locale import logging import os import re import shlex import subprocess from time import sleep from typing import Any, Generator import click from configobj import ConfigObj from pymysql.cursors import Cursor import pyperclip import sqlparse from mycli.compat import WIN from mycli.packages.prompt_utils import confirm_destructive_query from mycli.packages.special.delimitercommand import DelimiterCommand from mycli.packages.special.favoritequeries import FavoriteQueries from mycli.packages.special.main import ArgType, special_command from mycli.packages.special.utils import handle_cd_command TIMING_ENABLED = False use_expanded_output = False force_horizontal_output = False PAGER_ENABLED = True tee_file = None once_file = None written_to_once_file = False PIPE_ONCE: dict[str, Any] = { 'process': None, 'stdin': [], 'stdout_file': None, 'stdout_mode': None, } delimiter_command = DelimiterCommand() favoritequeries = FavoriteQueries(ConfigObj()) def set_favorite_queries(config): global favoritequeries favoritequeries = FavoriteQueries(config) def set_timing_enabled(val: bool) -> None: global TIMING_ENABLED TIMING_ENABLED = val def set_pager_enabled(val: bool) -> None: global PAGER_ENABLED PAGER_ENABLED = val def is_pager_enabled() -> bool: return PAGER_ENABLED @special_command( "pager", "\\P [command]", "Set PAGER. Print the query results via PAGER.", arg_type=ArgType.PARSED_QUERY, aliases=["\\P"], case_sensitive=True, ) def set_pager(arg: str, **_) -> list[tuple]: if arg: os.environ["PAGER"] = arg msg = f"PAGER set to {arg}." set_pager_enabled(True) else: if "PAGER" in os.environ: msg = f"PAGER set to {os.environ['PAGER']}." else: # This uses click's default per echo_via_pager. msg = "Pager enabled." set_pager_enabled(True) return [(None, None, None, msg)] @special_command("nopager", "\\n", "Disable pager, print to stdout.", arg_type=ArgType.NO_QUERY, aliases=["\\n"], case_sensitive=True) def disable_pager() -> list[tuple]: set_pager_enabled(False) return [(None, None, None, "Pager disabled.")] @special_command("\\timing", "\\t", "Toggle timing of commands.", arg_type=ArgType.NO_QUERY, aliases=["\\t"], case_sensitive=True) def toggle_timing() -> list[tuple]: global TIMING_ENABLED TIMING_ENABLED = not TIMING_ENABLED message = "Timing is " message += "on." if TIMING_ENABLED else "off." return [(None, None, None, message)] def is_timing_enabled() -> bool: return TIMING_ENABLED def set_expanded_output(val: bool) -> None: global use_expanded_output use_expanded_output = val def is_expanded_output() -> bool: return use_expanded_output def set_forced_horizontal_output(val: bool) -> None: global force_horizontal_output force_horizontal_output = val def forced_horizontal() -> bool: return force_horizontal_output _logger = logging.getLogger(__name__) def editor_command(command: str) -> bool: """ Is this an external editor command? :param command: string """ # It is possible to have `\e filename` or `SELECT * FROM \e`. So we check # for both conditions. return command.strip().endswith("\\e") or command.strip().startswith("\\e") def get_filename(sql: str) -> str | None: if sql.strip().startswith("\\e"): command, _, filename = sql.partition(" ") return filename.strip() or None else: return None def get_editor_query(sql: str) -> str: """Get the query part of an editor command.""" sql = sql.strip() # The reason we can't simply do .strip('\e') is that it strips characters, # not a substring. So it'll strip "e" in the end of the sql also! # Ex: "select * from style\e" -> "select * from styl". pattern = re.compile(r"(^\\e|\\e$)") while pattern.search(sql): sql = pattern.sub("", sql) return sql def open_external_editor(filename: str | None = None, sql: str | None = None) -> tuple[str, str | None]: """Open external editor, wait for the user to type in their query, return the query. """ filename = filename.strip().split(" ", 1)[0] if filename else None sql = sql or "" MARKER = "# Type your query above this line.\n" if filename: query = '' message = None click.edit(filename=filename) try: with open(filename, 'r') as f: query = f.read() except IOError: message = f'Error reading file: {filename}' return (query, message) # Populate the editor buffer with the partial sql (if available) and a # placeholder comment. query = click.edit(f"{sql}\n\n{MARKER}", extension=".sql") or '' if query: query = query.split(MARKER, 1)[0].rstrip("\n") else: # Don't return None for the caller to deal with. # Empty string is ok. query = sql return (query, None) def clip_command(command: str) -> bool: """Is this a clip command? :param command: string """ # It is possible to have `\clip` or `SELECT * FROM \clip`. So we check # for both conditions. return command.strip().endswith("\\clip") or command.strip().startswith("\\clip") def get_clip_query(sql: str) -> str: """Get the query part of a clip command.""" sql = sql.strip() # The reason we can't simply do .strip('\clip') is that it strips characters, # not a substring. So it'll strip "c" in the end of the sql also! pattern = re.compile(r"(^\\clip|\\clip$)") while pattern.search(sql): sql = pattern.sub("", sql) return sql def copy_query_to_clipboard(sql: str | None = None) -> str | None: """Send query to the clipboard.""" sql = sql or "" message = None try: pyperclip.copy(f"{sql}") except RuntimeError as e: message = f"Error clipping query: {e}." return message def set_redirect(command_part: str | None, file_operator_part: str | None, file_part: str | None) -> list[tuple]: if command_part: if file_part: PIPE_ONCE['stdout_file'] = file_part PIPE_ONCE['stdout_mode'] = 'w' if file_operator_part == '>' else 'a' return set_pipe_once(command_part) elif file_operator_part == '>': return set_once(f'-o {file_part}') else: return set_once(file_part) @special_command("\\f", "\\f [name [args..]]", "List or execute favorite queries.", arg_type=ArgType.PARSED_QUERY, case_sensitive=True) def execute_favorite_query(cur: Cursor, arg: str, **_) -> Generator[tuple, None, None]: """Returns (title, rows, headers, status)""" if arg == "": for result in list_favorite_queries(): yield result # Parse out favorite name and optional substitution parameters name, _separator, arg_str = arg.partition(" ") args = shlex.split(arg_str) query = FavoriteQueries.instance.get(name) if query is None: message = f"No favorite query: {name}" yield (None, None, None, message) else: query, arg_error = subst_favorite_query_args(query, args) if arg_error: yield (None, None, None, arg_error) else: for sql in sqlparse.split(query): sql = sql.rstrip(";") title = f"> {sql}" cur.execute(sql) if cur.description: headers = [x[0] for x in cur.description] yield (title, cur, headers, None) else: yield (title, None, None, None) def list_favorite_queries() -> list[tuple]: """List of all favorite queries. Returns (title, rows, headers, status)""" headers = ["Name", "Query"] rows = [(r, FavoriteQueries.instance.get(r)) for r in FavoriteQueries.instance.list()] if not rows: status = "\nNo favorite queries found." + FavoriteQueries.instance.usage else: status = "" return [("", rows, headers, status)] def subst_favorite_query_args(query: str, args: list[str]) -> list[str | None]: """replace positional parameters ($1...$N) in query.""" for idx, val in enumerate(args): subst_var = "$" + str(idx + 1) if subst_var not in query: return [None, "query does not have substitution parameter " + subst_var + ":\n " + query] query = query.replace(subst_var, val) match = re.search(r"\$\d+", query) if match: return [None, "missing substitution for " + match.group(0) + " in query:\n " + query] return [query, None] @special_command("\\fs", "\\fs name query", "Save a favorite query.") def save_favorite_query(arg: str, **_) -> list[tuple]: """Save a new favorite query. Returns (title, rows, headers, status)""" usage = "Syntax: \\fs name query.\n\n" + FavoriteQueries.instance.usage if not arg: return [(None, None, None, usage)] name, _separator, query = arg.partition(" ") # If either name or query is missing then print the usage and complain. if (not name) or (not query): return [(None, None, None, usage + "Err: Both name and query are required.")] FavoriteQueries.instance.save(name, query) return [(None, None, None, "Saved.")] @special_command("\\fd", "\\fd [name]", "Delete a favorite query.") def delete_favorite_query(arg: str, **_) -> list[tuple]: """Delete an existing favorite query.""" usage = "Syntax: \\fd name.\n\n" + FavoriteQueries.instance.usage if not arg: return [(None, None, None, usage)] status = FavoriteQueries.instance.delete(arg) return [(None, None, None, status)] @special_command("system", "system [command]", "Execute a system shell commmand.") def execute_system_command(arg: str, **_) -> list[tuple]: """Execute a system shell command.""" usage = "Syntax: system [command].\n" if not arg: return [(None, None, None, usage)] try: command = arg.strip() if command.startswith("cd"): ok, error_message = handle_cd_command(arg) if not ok: return [(None, None, None, error_message)] return [(None, None, None, "")] args = arg.split(" ") process = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE) output, error = process.communicate() response = output if not error else error encoding = locale.getpreferredencoding(False) response_str = response.decode(encoding) return [(None, None, None, response_str)] except OSError as e: return [(None, None, None, f"OSError: {e.strerror}")] def parseargfile(arg: str) -> tuple[str, str]: if arg.startswith("-o "): mode = "w" filename = arg[3:] else: mode = "a" filename = arg if not filename: raise TypeError("You must provide a filename.") return (os.path.expanduser(filename), mode) @special_command("tee", "tee [-o] filename", "Append all results to an output file (overwrite using -o).") def set_tee(arg: str, **_) -> list[tuple]: global tee_file try: tee_file = open(*parseargfile(arg)) except (IOError, OSError) as e: raise OSError(f"Cannot write to file '{e.filename}': {e.strerror}") from e return [(None, None, None, "")] def close_tee() -> None: global tee_file if tee_file: tee_file.close() tee_file = None @special_command("notee", "notee", "Stop writing results to an output file.") def no_tee(arg: str, **_) -> list[tuple]: close_tee() return [(None, None, None, "")] def write_tee(output: str) -> None: global tee_file if tee_file: click.echo(output, file=tee_file, nl=False) click.echo("\n", file=tee_file, nl=False) tee_file.flush() @special_command("\\once", "\\o [-o] filename", "Append next result to an output file (overwrite using -o).", aliases=["\\o"]) def set_once(arg: str, **_) -> list[tuple]: global once_file, written_to_once_file try: once_file = open(*parseargfile(arg)) except (IOError, OSError) as e: raise OSError(f"Cannot write to file '{e.filename}': {e.strerror}") from e written_to_once_file = False return [(None, None, None, "")] def is_redirected() -> bool: return bool(once_file or PIPE_ONCE['process']) def write_once(output: str) -> None: global once_file, written_to_once_file if output and once_file: click.echo(output, file=once_file, nl=False) click.echo("\n", file=once_file, nl=False) once_file.flush() written_to_once_file = True def unset_once_if_written(post_redirect_command: str) -> None: """Unset the once file, if it has been written to.""" global once_file, written_to_once_file if written_to_once_file and once_file: once_filename = once_file.name once_file.close() once_file = None _run_post_redirect_hook(post_redirect_command, once_filename) def _run_post_redirect_hook(post_redirect_command: str, filename: str) -> None: if not post_redirect_command: return post_cmd = post_redirect_command.format(shlex.quote(filename)) try: subprocess.run( post_cmd, shell=True, check=True, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, ) except Exception as e: raise OSError(f"Redirect post hook failed: {e}") from e @special_command("\\pipe_once", "\\| command", "Send next result to a subprocess.", aliases=["\\|"]) def set_pipe_once(arg: str, **_) -> list[tuple]: if not arg: raise OSError("pipe_once requires a command") if WIN: # best effort, no chaining pipe_once_cmd = shlex.split(arg) else: # to support chaining pipe_once_cmd = ['sh', '-c', arg] PIPE_ONCE['stdin'] = [] PIPE_ONCE['process'] = subprocess.Popen( pipe_once_cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, encoding="UTF-8", universal_newlines=True, ) return [(None, None, None, "")] def write_pipe_once(line: str) -> None: if line and PIPE_ONCE['process']: PIPE_ONCE['stdin'].append(line) def flush_pipe_once_if_written(post_redirect_command: str) -> None: """Flush the pipe_once cmd, if lines have been written.""" if not PIPE_ONCE['process']: return if not PIPE_ONCE['stdin']: return try: (stdout_data, stderr_data) = PIPE_ONCE['process'].communicate(input='\n'.join(PIPE_ONCE['stdin']) + '\n', timeout=60) except subprocess.TimeoutExpired: PIPE_ONCE['process'].kill() (stdout_data, stderr_data) = PIPE_ONCE['process'].communicate() if stdout_data: if PIPE_ONCE['stdout_file']: with open(PIPE_ONCE['stdout_file'], PIPE_ONCE['stdout_mode']) as f: print(stdout_data, file=f) _run_post_redirect_hook(post_redirect_command, PIPE_ONCE['stdout_file']) else: click.secho(stdout_data.rstrip('\n')) if stderr_data: click.secho(stderr_data.rstrip('\n'), err=True, fg='red') if returncode := PIPE_ONCE['process'].returncode: PIPE_ONCE['process'] = None PIPE_ONCE['stdin'] = [] PIPE_ONCE['stdout_file'] = None PIPE_ONCE['stdout_mode'] = None raise OSError(f'process exited with nonzero code {returncode}') PIPE_ONCE['process'] = None PIPE_ONCE['stdin'] = [] PIPE_ONCE['stdout_file'] = None PIPE_ONCE['stdout_mode'] = None @special_command("watch", "watch [seconds] [-c] query", "Executes the query every [seconds] seconds (by default 5).") def watch_query(arg: str, **kwargs) -> Generator[tuple, None, None]: usage = """Syntax: watch [seconds] [-c] query. * seconds: The interval at the query will be repeated, in seconds. By default 5. * -c: Clears the screen between every iteration. """ if not arg: yield (None, None, None, usage) return seconds = 5.0 clear_screen = False statement = None while statement is None: arg = arg.strip() if not arg: # Oops, we parsed all the arguments without finding a statement yield (None, None, None, usage) return (left_arg, _, right_arg) = arg.partition(" ") arg = right_arg try: seconds = float(left_arg) continue except ValueError: pass if left_arg == "-c": clear_screen = True continue statement = f"{left_arg} {arg}" destructive_prompt = confirm_destructive_query(statement) if destructive_prompt is False: click.secho("Wise choice!") return elif destructive_prompt is True: click.secho("Your call!") cur = kwargs["cur"] sql_list = [(sql.rstrip(";"), f"> {sql}") for sql in sqlparse.split(statement)] old_pager_enabled = is_pager_enabled() while True: if clear_screen: click.clear() try: # Somewhere in the code the pager its activated after every yield, # so we disable it in every iteration set_pager_enabled(False) for sql, title in sql_list: cur.execute(sql) if cur.description: headers = [x[0] for x in cur.description] yield (title, cur, headers, None) else: yield (title, None, None, None) sleep(seconds) except KeyboardInterrupt: # This prints the Ctrl-C character in its own line, which prevents # to print a line with the cursor positioned behind the prompt click.secho("", nl=True) return finally: set_pager_enabled(old_pager_enabled) @special_command("delimiter", None, "Change SQL delimiter.") def set_delimiter(arg: str, **_) -> list[tuple]: return delimiter_command.set(arg) def get_current_delimiter() -> str: return delimiter_command.current def split_queries(input_str: str) -> Generator[str, None, None]: for query in delimiter_command.queries_iter(input_str): yield query ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/packages/special/llm.py0000644000175100017510000002213015101406164020025 0ustar00runnerrunnerimport contextlib import functools import io import logging import os import re from runpy import run_module import shlex import sys from time import time from typing import Any import click try: if not os.environ.get('MYCLI_LLM_OFF'): import llm LLM_IMPORTED = True else: LLM_IMPORTED = False except ImportError: LLM_IMPORTED = False try: if not os.environ.get('MYCLI_LLM_OFF'): from llm.cli import cli LLM_CLI_IMPORTED = True else: LLM_CLI_IMPORTED = False except ImportError: LLM_CLI_IMPORTED = False from pymysql.cursors import Cursor from mycli.packages.special.main import Verbosity, parse_special_command log = logging.getLogger(__name__) LLM_TEMPLATE_NAME = "mycli-llm-template" def run_external_cmd( cmd: str, *args, capture_output=False, restart_cli=False, raise_exception=True, ) -> tuple[int, str]: original_exe = sys.executable original_args = sys.argv try: sys.argv = [cmd] + list(args) code = 0 if capture_output: buffer = io.StringIO() redirect: contextlib.ExitStack[bool | None] | contextlib.nullcontext[None] = contextlib.ExitStack() assert isinstance(redirect, contextlib.ExitStack) redirect.enter_context(contextlib.redirect_stdout(buffer)) redirect.enter_context(contextlib.redirect_stderr(buffer)) else: redirect = contextlib.nullcontext() with redirect: try: run_module(cmd, run_name="__main__") except SystemExit as e: code = int(e.code or 0) if code != 0 and raise_exception: if capture_output: raise RuntimeError(buffer.getvalue()) from e raise RuntimeError(f"Command {cmd} failed with exit code {code}.") from e except Exception as e: code = 1 if raise_exception: if capture_output: raise RuntimeError(buffer.getvalue()) from e raise RuntimeError(f"Command {cmd} failed: {e}") from e if restart_cli and code == 0: os.execv(original_exe, [original_exe] + original_args) if capture_output: return code, buffer.getvalue() else: return code, "" finally: sys.argv = original_args def _build_command_tree(cmd) -> dict[str, Any] | None: tree: dict[str, Any] | None = {} assert isinstance(tree, dict) if isinstance(cmd, click.Group): for name, subcmd in cmd.commands.items(): if cmd.name == "models" and name == "default": tree[name] = {x.model_id: None for x in llm.get_models()} else: tree[name] = _build_command_tree(subcmd) else: tree = None return tree def build_command_tree(cmd) -> dict[str, Any]: return _build_command_tree(cmd) or {} # Generate the command tree for autocompletion COMMAND_TREE = build_command_tree(cli) if LLM_CLI_IMPORTED is True else {} def get_completions( tokens: list[str], tree: dict[str, Any] | None = None, ) -> list[str]: tree = tree or COMMAND_TREE for token in tokens: if token.startswith("-"): continue if tree and token in tree: tree = tree[token] else: return [] return list(tree.keys()) if tree else [] class FinishIteration(Exception): def __init__(self, results=None): self.results = results USAGE = """ Use an LLM to create SQL queries to answer questions from your database. Examples: # Ask a question. > \\llm 'Most visited urls?' # List available models > \\llm models > gpt-4o > gpt-3.5-turbo # Change default model > \\llm models default llama3 # Set api key (not required for local models) > \\llm keys set openai # Install a model plugin > \\llm install llm-ollama > llm-ollama installed. # Plugins directory # https://llm.datasette.io/en/stable/plugins/directory.html """ NEED_DEPENDENCIES = """ To enable LLM features you need to install mycli with LLM support: pip install 'mycli[llm]' or pip install 'mycli[all]' or install LLM libraries separately pip install llm This is required to use the \\llm command. """ _SQL_CODE_FENCE = r"```sql\n(.*?)\n```" PROMPT = """ You are a helpful assistant who is a MySQL expert. You are embedded in a mysql cli tool called mycli. Answer this question: $question Use the following context if it is relevant to answering the question. If the question is not about the current database then ignore the context. You are connected to a MySQL database with the following schema: $db_schema Here is a sample row of data from each table: $sample_data If the answer can be found using a SQL query, include a sql query in a code fence such as this one: ```sql SELECT count(*) FROM table_name; ``` Keep your explanation concise and focused on the question asked. """ def ensure_mycli_template(replace: bool = False) -> None: if not replace: code, _ = run_external_cmd("llm", "templates", "show", LLM_TEMPLATE_NAME, capture_output=True, raise_exception=False) if code == 0: return run_external_cmd("llm", PROMPT, "--save", LLM_TEMPLATE_NAME) @functools.cache def cli_commands() -> list[str]: return list(cli.commands.keys()) def handle_llm(text: str, cur: Cursor) -> tuple[str, str | None, float]: _, verbosity, arg = parse_special_command(text) if not LLM_IMPORTED: output = [(None, None, None, NEED_DEPENDENCIES)] raise FinishIteration(output) if not arg.strip(): output = [(None, None, None, USAGE)] raise FinishIteration(output) parts = shlex.split(arg) restart = False if "-c" in parts: capture_output = True use_context = False elif "prompt" in parts: capture_output = True use_context = True elif "install" in parts or "uninstall" in parts: capture_output = False use_context = False restart = True elif parts and parts[0] in cli_commands(): capture_output = False use_context = False elif parts and parts[0] == "--help": capture_output = False use_context = False else: capture_output = True use_context = True if not use_context: args = parts if capture_output: click.echo("Calling llm command") start = time() _, result = run_external_cmd("llm", *args, capture_output=capture_output) end = time() match = re.search(_SQL_CODE_FENCE, result, re.DOTALL) if match: sql = match.group(1).strip() else: output = [(None, None, None, result)] raise FinishIteration(output) return (result if verbosity == Verbosity.SUCCINCT else "", sql, end - start) else: run_external_cmd("llm", *args, restart_cli=restart) raise FinishIteration(None) try: ensure_mycli_template() start = time() context, sql = sql_using_llm(cur=cur, question=arg) end = time() if verbosity == Verbosity.SUCCINCT: context = "" return (context, sql, end - start) except Exception as e: raise RuntimeError(e) from e def is_llm_command(command: str) -> bool: cmd, _, _ = parse_special_command(command) return cmd in ("\\llm", "\\ai") def sql_using_llm( cur: Cursor | None, question: str | None = None, ) -> tuple[str, str | None]: if cur is None: raise RuntimeError("Connect to a database and try again.") schema_query = """ SELECT CONCAT(table_name, '(', GROUP_CONCAT(column_name, ' ', COLUMN_TYPE SEPARATOR ', '),')') FROM information_schema.columns WHERE table_schema = DATABASE() GROUP BY table_name ORDER BY table_name """ tables_query = "SHOW TABLES" sample_row_query = "SELECT * FROM `{table}` LIMIT 1" click.echo("Preparing schema information to feed the llm") cur.execute(schema_query) db_schema = "\n".join([row[0] for (row,) in cur.fetchall()]) cur.execute(tables_query) sample_data = {} for (table_name,) in cur.fetchall(): try: cur.execute(sample_row_query.format(table=table_name)) except Exception: continue cols = [desc[0] for desc in cur.description] row = cur.fetchone() if row is None: continue sample_data[table_name] = list(zip(cols, row)) args = [ "--template", LLM_TEMPLATE_NAME, "--param", "db_schema", db_schema, "--param", "sample_data", sample_data, "--param", "question", question, " ", ] click.echo("Invoking llm command with schema information") _, result = run_external_cmd("llm", *args, capture_output=True) click.echo("Received response from the llm command") match = re.search(_SQL_CODE_FENCE, result, re.DOTALL) if match: sql = match.group(1).strip() else: sql = "" return (result, sql) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/packages/special/main.py0000644000175100017510000001275715101406164020203 0ustar00runnerrunnerfrom collections import namedtuple from enum import Enum import logging import os from typing import Callable try: if not os.environ.get('MYCLI_LLM_OFF'): import llm # noqa: F401 LLM_IMPORTED = True else: LLM_IMPORTED = False except ImportError: LLM_IMPORTED = False from pymysql.cursors import Cursor logger = logging.getLogger(__name__) COMMANDS = {} SpecialCommand = namedtuple( "SpecialCommand", [ "handler", "command", "shortcut", "description", "arg_type", "hidden", "case_sensitive", ], ) class ArgType(Enum): NO_QUERY = 0 PARSED_QUERY = 1 RAW_QUERY = 2 class CommandNotFound(Exception): pass class Verbosity(Enum): SUCCINCT = "succinct" NORMAL = "normal" VERBOSE = "verbose" def parse_special_command(sql: str) -> tuple[str, Verbosity, str]: command, _, arg = sql.partition(" ") verbosity = Verbosity.NORMAL if "+" in command: verbosity = Verbosity.VERBOSE elif "-" in command: verbosity = Verbosity.SUCCINCT command = command.strip().strip("+-") return (command, verbosity, arg.strip()) def special_command( command: str, shortcut: str | None, description: str, arg_type: ArgType = ArgType.PARSED_QUERY, hidden: bool = False, case_sensitive: bool = False, aliases: list[str] | None = None, ) -> Callable: def wrapper(wrapped): register_special_command( wrapped, command, shortcut, description, arg_type=arg_type, hidden=hidden, case_sensitive=case_sensitive, aliases=aliases, ) return wrapped return wrapper def register_special_command( handler: Callable, command: str, shortcut: str | None, description: str, arg_type: ArgType = ArgType.PARSED_QUERY, hidden: bool = False, case_sensitive: bool = False, aliases: list[str] | None = None, ) -> None: cmd = command.lower() if not case_sensitive else command COMMANDS[cmd] = SpecialCommand( handler, command, shortcut, description, arg_type=arg_type, hidden=hidden, case_sensitive=case_sensitive, ) aliases = [] if aliases is None else aliases for alias in aliases: cmd = alias.lower() if not case_sensitive else alias COMMANDS[cmd] = SpecialCommand( handler, command, shortcut, description, arg_type=arg_type, case_sensitive=case_sensitive, hidden=True, ) def execute(cur: Cursor, sql: str) -> list[tuple]: """Execute a special command and return the results. If the special command is not supported a CommandNotFound will be raised. """ command, verbosity, arg = parse_special_command(sql) if (command not in COMMANDS) and (command.lower() not in COMMANDS): raise CommandNotFound() try: special_cmd = COMMANDS[command] except KeyError as exc: special_cmd = COMMANDS[command.lower()] if special_cmd.case_sensitive: raise CommandNotFound(f'Command not found: {command}') from exc # "help is a special case. We want built-in help, not # mycli help here. if command == "help" and arg: return show_keyword_help(cur=cur, arg=arg) if special_cmd.arg_type == ArgType.NO_QUERY: return special_cmd.handler() elif special_cmd.arg_type == ArgType.PARSED_QUERY: return special_cmd.handler(cur=cur, arg=arg, verbose=(verbosity == Verbosity.VERBOSE)) elif special_cmd.arg_type == ArgType.RAW_QUERY: return special_cmd.handler(cur=cur, query=sql) raise CommandNotFound(f"Command type not found: {command}") @special_command("help", "\\?", "Show this help.", arg_type=ArgType.NO_QUERY, aliases=["\\?", "?"]) def show_help(*_args) -> list[tuple]: headers = ["Command", "Shortcut", "Description"] result = [] for _, value in sorted(COMMANDS.items()): if not value.hidden: result.append((value.command, value.shortcut, value.description)) return [(None, result, headers, None)] def show_keyword_help(cur: Cursor, arg: str) -> list[tuple]: """ Call the built-in "show ", to display help for an SQL keyword. :param cur: cursor :param arg: string :return: list """ keyword = arg.strip('"').strip("'") query = f"help '{keyword}'" logger.debug(query) cur.execute(query) if cur.description and cur.rowcount > 0: headers = [x[0] for x in cur.description] return [(None, cur, headers, "")] else: return [(None, None, None, f'No help found for {keyword}.')] @special_command("exit", "\\q", "Exit.", arg_type=ArgType.NO_QUERY, aliases=["\\q"]) @special_command("quit", "\\q", "Quit.", arg_type=ArgType.NO_QUERY) def quit_(*_args): raise EOFError @special_command("\\e", "\\e", "Edit command with editor (uses $EDITOR).", arg_type=ArgType.NO_QUERY, case_sensitive=True) @special_command("\\clip", "\\clip", "Copy query to the system clipboard.", arg_type=ArgType.NO_QUERY, case_sensitive=True) @special_command("\\G", "\\G", "Display current query results vertically.", arg_type=ArgType.NO_QUERY, case_sensitive=True) def stub(): raise NotImplementedError if LLM_IMPORTED: @special_command("\\llm", "\\ai", "Interrogate LLM.", arg_type=ArgType.RAW_QUERY, case_sensitive=True) def llm_stub(): raise NotImplementedError ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/packages/special/utils.py0000644000175100017510000000271315101406164020406 0ustar00runnerrunnerimport os import subprocess def handle_cd_command(arg: str) -> tuple[bool, str | None]: """Handles a `cd` shell command by calling python's os.chdir.""" CD_CMD = "cd" tokens = arg.split(CD_CMD + " ") directory = tokens[-1] if len(tokens) > 1 else None if not directory: return False, "No folder name was provided." try: os.chdir(directory) subprocess.call(["pwd"]) return True, None except OSError as e: return False, e.strerror def format_uptime(uptime_in_seconds: str) -> str: """Format number of seconds into human-readable string. :param uptime_in_seconds: The server uptime in seconds. :returns: A human-readable string representing the uptime. >>> uptime = format_uptime('56892') >>> print(uptime) 15 hours 48 min 12 sec """ m, s = divmod(int(uptime_in_seconds), 60) h, m = divmod(m, 60) d, h = divmod(h, 24) uptime_values: list[str] = [] for value, unit in ((d, "days"), (h, "hours"), (m, "min"), (s, "sec")): if value == 0 and not uptime_values: # Don't include a value/unit if the unit isn't applicable to # the uptime. E.g. don't do 0 days 0 hours 1 min 30 sec. continue if value == 1 and unit.endswith("s"): # Remove the "s" if the unit is singular. unit = unit[:-1] uptime_values.append(f'{value} {unit}') uptime = " ".join(uptime_values) return uptime ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1762004092.2888172 mycli-1.41.0/mycli/packages/tabular_output/0000755000175100017510000000000015101406174020324 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/packages/tabular_output/__init__.py0000644000175100017510000000000015101406164022422 0ustar00runnerrunner././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/packages/tabular_output/sql_format.py0000644000175100017510000000433615101406164023052 0ustar00runnerrunner"""Format adapter for sql.""" from __future__ import annotations from typing import Generator, Union from cli_helpers.tabular_output import TabularOutputFormatter from mycli.packages.parseutils import extract_tables_from_complete_statements supported_formats = ( "sql-insert", "sql-update", "sql-update-1", "sql-update-2", ) preprocessors = () formatter: TabularOutputFormatter def escape_for_sql_statement(value: Union[bytes, str]) -> str: if isinstance(value, bytes): return f"X'{value.hex()}'" else: return formatter.mycli.sqlexecute.conn.escape(value) def adapter(data: list[str], headers: list[str], table_format: Union[str, None] = None, **kwargs) -> Generator[str, None, None]: tables = extract_tables_from_complete_statements(formatter.query) if len(tables) > 0: table = tables[0] if table[0]: table_name = f'{table[0]}.{table[1]}' else: table_name = table[1] else: table_name = "`DUAL`" if table_format == "sql-insert": h = "`, `".join(headers) yield f'INSERT INTO {table_name} (`{h}`) VALUES' prefix = " " for d in data: values = ", ".join(escape_for_sql_statement(v) for i, v in enumerate(d)) yield f'{prefix}({values})' if prefix == " ": prefix = ", " yield ";" if table_format and table_format.startswith("sql-update"): s = table_format.split("-") keys = 1 if len(s) > 2: keys = int(s[-1]) for d in data: yield f'UPDATE {table_name} SET' prefix = " " for i, v in enumerate(d[keys:], keys): yield f'{prefix}`{headers[i]}` = {escape_for_sql_statement(v)}' if prefix == " ": prefix = ", " f = "`{}` = {}" where = (f.format(headers[i], escape_for_sql_statement(d[i])) for i in range(keys)) yield f'WHERE {" AND ".join(where)};' def register_new_formatter(tof: TabularOutputFormatter): global formatter formatter = tof for sql_format in supported_formats: tof.register_new_formatter(sql_format, adapter, preprocessors, {"table_format": sql_format}) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1762004092.2898173 mycli-1.41.0/mycli/packages/toolkit/0000755000175100017510000000000015101406174016737 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/packages/toolkit/__init__.py0000644000175100017510000000000015101406164021035 0ustar00runnerrunner././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/packages/toolkit/fzf.py0000644000175100017510000000342115101406164020075 0ustar00runnerrunnerimport re from shutil import which from prompt_toolkit import search from prompt_toolkit.key_binding.key_processor import KeyPressEvent from pyfzf import FzfPrompt from mycli.packages.toolkit.history import FileHistoryWithTimestamp class Fzf(FzfPrompt): def __init__(self): self.executable = which("fzf") if self.executable: super().__init__() def is_available(self) -> bool: return self.executable is not None def search_history(event: KeyPressEvent, incremental: bool = False) -> None: buffer = event.current_buffer history = buffer.history fzf = Fzf() if incremental or not fzf.is_available() or not isinstance(history, FileHistoryWithTimestamp): # Fallback to default reverse incremental search search.start_search(direction=search.SearchDirection.BACKWARD) return history_items_with_timestamp = history.load_history_with_timestamp() formatted_history_items = [] original_history_items = [] seen = {} for item, timestamp in history_items_with_timestamp: formatted_item = re.sub(r'\s+', ' ', item) timestamp = timestamp.split(".")[0] if "." in timestamp else timestamp if formatted_item in seen: continue seen[formatted_item] = True formatted_history_items.append(f"{timestamp} {formatted_item}") original_history_items.append(item) result = fzf.prompt( formatted_history_items, fzf_options="--scheme=history --tiebreak=index --bind ctrl-r:up,alt-r:up --preview-window=down:wrap --preview=\"printf '%s' {}\"", ) if result: selected_index = formatted_history_items.index(result[0]) buffer.text = original_history_items[selected_index] buffer.cursor_position = len(buffer.text) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/packages/toolkit/history.py0000644000175100017510000000311315101406164021007 0ustar00runnerrunnerimport os from typing import Union from prompt_toolkit.history import FileHistory _StrOrBytesPath = Union[str, bytes, os.PathLike] class FileHistoryWithTimestamp(FileHistory): """ :class:`.FileHistory` class that stores all strings in a file with timestamp. """ def __init__(self, filename: _StrOrBytesPath) -> None: self.filename = filename super().__init__(filename) def load_history_with_timestamp(self) -> list[tuple[str, str]]: """ Load history entries along with their timestamps. Returns: list[tuple[str, str]]: A list of tuples where each tuple contains a history entry and its corresponding timestamp. """ history_with_timestamp: list[tuple[str, str]] = [] lines: list[str] = [] timestamp: str = "" def add() -> None: if lines: # Join and drop trailing newline. string = "".join(lines)[:-1] history_with_timestamp.append((string, timestamp)) if os.path.exists(self.filename): with open(self.filename, 'r', encoding='utf-8') as f: for line in f: if line.startswith("#"): # Extract timestamp timestamp = line[2:].strip() elif line.startswith("+"): lines.append(line[1:]) else: add() lines = [] add() return list(reversed(history_with_timestamp)) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/sqlcompleter.py0000644000175100017510000010206215101406164016560 0ustar00runnerrunnerfrom __future__ import annotations from collections import Counter import logging import re from typing import Any, Collection, Generator, Iterable, Literal from prompt_toolkit.completion import CompleteEvent, Completer, Completion from prompt_toolkit.completion.base import Document from mycli.packages.completion_engine import suggest_type from mycli.packages.filepaths import complete_path, parse_path, suggest_path from mycli.packages.parseutils import last_word from mycli.packages.special import llm from mycli.packages.special.favoritequeries import FavoriteQueries _logger = logging.getLogger(__name__) class SQLCompleter(Completer): keywords = [ "SELECT", "FROM", "WHERE", "UPDATE", "DELETE FROM", "GROUP BY", "JOIN", "INSERT INTO", "LIKE", "LIMIT", "ACCESS", "ADD", "ALL", "ALTER TABLE", "AND", "ANY", "AS", "ASC", "AUTO_INCREMENT", "BEFORE", "BEGIN", "BETWEEN", "BIGINT", "BINARY", "BY", "CASE", "CHANGE MASTER TO", "CHAR", "CHARACTER SET", "CHECK", "COLLATE", "COLUMN", "COMMENT", "COMMIT", "CONSTRAINT", "CREATE", "CURRENT", "CURRENT_TIMESTAMP", "DATABASE", "DATE", "DECIMAL", "DEFAULT", "DESC", "DESCRIBE", "DROP", "ELSE", "END", "ENGINE", "ESCAPE", "EXISTS", "FILE", "FLOAT", "FOR", "FOREIGN KEY", "FORMAT", "FULL", "FUNCTION", "GRANT", "HAVING", "HOST", "IDENTIFIED", "IN", "INCREMENT", "INDEX", "INT", "INTEGER", "INTERVAL", "INTO", "IS", "KEY", "LEFT", "LEVEL", "LOCK", "LOGS", "LONG", "MASTER", "MEDIUMINT", "MODE", "MODIFY", "NOT", "NULL", "NUMBER", "OFFSET", "ON", "OPTION", "OR", "ORDER BY", "OUTER", "OWNER", "PASSWORD", "PORT", "PRIMARY", "PRIVILEGES", "PROCESSLIST", "PURGE", "REFERENCES", "REGEXP", "RENAME", "REPAIR", "RESET", "REVOKE", "RIGHT", "ROLLBACK", "ROW", "ROWS", "ROW_FORMAT", "SAVEPOINT", "SESSION", "SET", "SHARE", "SHOW", "SLAVE", "SMALLINT", "START", "STOP", "TABLE", "THEN", "TINYINT", "TO", "TRANSACTION", "TRIGGER", "TRUNCATE", "UNION", "UNIQUE", "UNSIGNED", "USE", "USER", "USING", "VALUES", "VARCHAR", "VIEW", "WHEN", "WITH", ] tidb_keywords = [ "SELECT", "FROM", "WHERE", "DELETE FROM", "UPDATE", "GROUP BY", "JOIN", "INSERT INTO", "LIKE", "LIMIT", "ACCOUNT", "ACTION", "ADD", "ADDDATE", "ADMIN", "ADVISE", "AFTER", "AGAINST", "AGO", "ALGORITHM", "ALL", "ALTER", "ALWAYS", "ANALYZE", "AND", "ANY", "APPROX_COUNT_DISTINCT", "APPROX_PERCENTILE", "AS", "ASC", "ASCII", "ATTRIBUTES", "AUTO_ID_CACHE", "AUTO_INCREMENT", "AUTO_RANDOM", "AUTO_RANDOM_BASE", "AVG", "AVG_ROW_LENGTH", "BACKEND", "BACKUP", "BACKUPS", "BATCH", "BEGIN", "BERNOULLI", "BETWEEN", "BIGINT", "BINARY", "BINDING", "BINDINGS", "BINDING_CACHE", "BINLOG", "BIT", "BIT_AND", "BIT_OR", "BIT_XOR", "BLOB", "BLOCK", "BOOL", "BOOLEAN", "BOTH", "BOUND", "BRIEF", "BTREE", "BUCKETS", "BUILTINS", "BY", "BYTE", "CACHE", "CALL", "CANCEL", "CAPTURE", "CARDINALITY", "CASCADE", "CASCADED", "CASE", "CAST", "CAUSAL", "CHAIN", "CHANGE", "CHAR", "CHARACTER", "CHARSET", "CHECK", "CHECKPOINT", "CHECKSUM", "CIPHER", "CLEANUP", "CLIENT", "CLIENT_ERRORS_SUMMARY", "CLUSTERED", "CMSKETCH", "COALESCE", "COLLATE", "COLLATION", "COLUMN", "COLUMNS", "COLUMN_FORMAT", "COLUMN_STATS_USAGE", "COMMENT", "COMMIT", "COMMITTED", "COMPACT", "COMPRESSED", "COMPRESSION", "CONCURRENCY", "CONFIG", "CONNECTION", "CONSISTENCY", "CONSISTENT", "CONSTRAINT", "CONSTRAINTS", "CONTEXT", "CONVERT", "COPY", "CORRELATION", "CPU", "CREATE", "CROSS", "CSV_BACKSLASH_ESCAPE", "CSV_DELIMITER", "CSV_HEADER", "CSV_NOT_NULL", "CSV_NULL", "CSV_SEPARATOR", "CSV_TRIM_LAST_SEPARATORS", "CUME_DIST", "CURRENT", "CURRENT_DATE", "CURRENT_ROLE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", "CURTIME", "CYCLE", "DATA", "DATABASE", "DATABASES", "DATE", "DATETIME", "DATE_ADD", "DATE_SUB", "DAY", "DAY_HOUR", "DAY_MICROSECOND", "DAY_MINUTE", "DAY_SECOND", "DDL", "DEALLOCATE", "DECIMAL", "DEFAULT", "DEFINER", "DELAYED", "DELAY_KEY_WRITE", "DENSE_RANK", "DEPENDENCY", "DEPTH", "DESC", "DESCRIBE", "DIRECTORY", "DISABLE", "DISABLED", "DISCARD", "DISK", "DISTINCT", "DISTINCTROW", "DIV", "DO", "DOT", "DOUBLE", "DRAINER", "DROP", "DRY", "DUAL", "DUMP", "DUPLICATE", "DYNAMIC", "ELSE", "ENABLE", "ENABLED", "ENCLOSED", "ENCRYPTION", "END", "ENFORCED", "ENGINE", "ENGINES", "ENUM", "ERROR", "ERRORS", "ESCAPE", "ESCAPED", "EVENT", "EVENTS", "EVOLVE", "EXACT", "EXCEPT", "EXCHANGE", "EXCLUSIVE", "EXECUTE", "EXISTS", "EXPANSION", "EXPIRE", "EXPLAIN", "EXPR_PUSHDOWN_BLACKLIST", "EXTENDED", "EXTRACT", "FALSE", "FAST", "FAULTS", "FETCH", "FIELDS", "FILE", "FIRST", "FIRST_VALUE", "FIXED", "FLASHBACK", "FLOAT", "FLUSH", "FOLLOWER", "FOLLOWERS", "FOLLOWER_CONSTRAINTS", "FOLLOWING", "FOR", "FORCE", "FOREIGN", "FORMAT", "FULL", "FULLTEXT", "FUNCTION", "GENERAL", "GENERATED", "GET_FORMAT", "GLOBAL", "GRANT", "GRANTS", "GROUPS", "GROUP_CONCAT", "HASH", "HAVING", "HELP", "HIGH_PRIORITY", "HISTOGRAM", "HISTOGRAMS_IN_FLIGHT", "HISTORY", "HOSTS", "HOUR", "HOUR_MICROSECOND", "HOUR_MINUTE", "HOUR_SECOND", "IDENTIFIED", "IF", "IGNORE", "IMPORT", "IMPORTS", "IN", "INCREMENT", "INCREMENTAL", "INDEX", "INDEXES", "INFILE", "INNER", "INPLACE", "INSERT_METHOD", "INSTANCE", "INSTANT", "INT", "INT1", "INT2", "INT3", "INT4", "INT8", "INTEGER", "INTERNAL", "INTERSECT", "INTERVAL", "INTO", "INVISIBLE", "INVOKER", "IO", "IPC", "IS", "ISOLATION", "ISSUER", "JOB", "JOBS", "JSON", "JSON_ARRAYAGG", "JSON_OBJECTAGG", "KEY", "KEYS", "KEY_BLOCK_SIZE", "KILL", "LABELS", "LAG", "LANGUAGE", "LAST", "LASTVAL", "LAST_BACKUP", "LAST_VALUE", "LEAD", "LEADER", "LEADER_CONSTRAINTS", "LEADING", "LEARNER", "LEARNERS", "LEARNER_CONSTRAINTS", "LEFT", "LESS", "LEVEL", "LINEAR", "LINES", "LIST", "LOAD", "LOCAL", "LOCALTIME", "LOCALTIMESTAMP", "LOCATION", "LOCK", "LOCKED", "LOGS", "LONG", "LONGBLOB", "LONGTEXT", "LOW_PRIORITY", "MASTER", "MATCH", "MAX", "MAXVALUE", "MAX_CONNECTIONS_PER_HOUR", "MAX_IDXNUM", "MAX_MINUTES", "MAX_QUERIES_PER_HOUR", "MAX_ROWS", "MAX_UPDATES_PER_HOUR", "MAX_USER_CONNECTIONS", "MB", "MEDIUMBLOB", "MEDIUMINT", "MEDIUMTEXT", "MEMORY", "MERGE", "MICROSECOND", "MIN", "MINUTE", "MINUTE_MICROSECOND", "MINUTE_SECOND", "MINVALUE", "MIN_ROWS", "MOD", "MODE", "MODIFY", "MONTH", "NAMES", "NATIONAL", "NATURAL", "NCHAR", "NEVER", "NEXT", "NEXTVAL", "NEXT_ROW_ID", "NO", "NOCACHE", "NOCYCLE", "NODEGROUP", "NODE_ID", "NODE_STATE", "NOMAXVALUE", "NOMINVALUE", "NONCLUSTERED", "NONE", "NORMAL", "NOT", "NOW", "NOWAIT", "NO_WRITE_TO_BINLOG", "NTH_VALUE", "NTILE", "NULL", "NULLS", "NUMERIC", "NVARCHAR", "OF", "OFF", "OFFSET", "ON", "ONLINE", "ONLY", "ON_DUPLICATE", "OPEN", "OPTIMISTIC", "OPTIMIZE", "OPTION", "OPTIONAL", "OPTIONALLY", "OPT_RULE_BLACKLIST", "OR", "ORDER", "OUTER", "OUTFILE", "OVER", "PACK_KEYS", "PAGE", "PARSER", "PARTIAL", "PARTITION", "PARTITIONING", "PARTITIONS", "PASSWORD", "PERCENT", "PERCENT_RANK", "PER_DB", "PER_TABLE", "PESSIMISTIC", "PLACEMENT", "PLAN", "PLAN_CACHE", "PLUGINS", "POLICY", "POSITION", "PRECEDING", "PRECISION", "PREDICATE", "PREPARE", "PRESERVE", "PRE_SPLIT_REGIONS", "PRIMARY", "PRIMARY_REGION", "PRIVILEGES", "PROCEDURE", "PROCESS", "PROCESSLIST", "PROFILE", "PROFILES", "PROXY", "PUMP", "PURGE", "QUARTER", "QUERIES", "QUERY", "QUICK", "RANGE", "RANK", "RATE_LIMIT", "READ", "REAL", "REBUILD", "RECENT", "RECOVER", "RECURSIVE", "REDUNDANT", "REFERENCES", "REGEXP", "REGION", "REGIONS", "RELEASE", "RELOAD", "REMOVE", "RENAME", "REORGANIZE", "REPAIR", "REPEAT", "REPEATABLE", "REPLACE", "REPLAYER", "REPLICA", "REPLICAS", "REPLICATION", "REQUIRE", "REQUIRED", "RESET", "RESPECT", "RESTART", "RESTORE", "RESTORES", "RESTRICT", "RESUME", "REVERSE", "REVOKE", "RIGHT", "RLIKE", "ROLE", "ROLLBACK", "ROUTINE", "ROW", "ROWS", "ROW_COUNT", "ROW_FORMAT", "ROW_NUMBER", "RTREE", "RUN", "RUNNING", "S3", "SAMPLERATE", "SAMPLES", "SAN", "SAVEPOINT", "SCHEDULE", "SECOND", "SECONDARY_ENGINE", "SECONDARY_LOAD", "SECONDARY_UNLOAD", "SECOND_MICROSECOND", "SECURITY", "SEND_CREDENTIALS_TO_TIKV", "SEPARATOR", "SEQUENCE", "SERIAL", "SERIALIZABLE", "SESSION", "SESSION_STATES", "SET", "SETVAL", "SHARD_ROW_ID_BITS", "SHARE", "SHARED", "SHOW", "SHUTDOWN", "SIGNED", "SIMPLE", "SKIP", "SKIP_SCHEMA_FILES", "SLAVE", "SLOW", "SMALLINT", "SNAPSHOT", "SOME", "SOURCE", "SPATIAL", "SPLIT", "SQL", "SQL_BIG_RESULT", "SQL_BUFFER_RESULT", "SQL_CACHE", "SQL_CALC_FOUND_ROWS", "SQL_NO_CACHE", "SQL_SMALL_RESULT", "SQL_TSI_DAY", "SQL_TSI_HOUR", "SQL_TSI_MINUTE", "SQL_TSI_MONTH", "SQL_TSI_QUARTER", "SQL_TSI_SECOND", "SQL_TSI_WEEK", "SQL_TSI_YEAR", "SSL", "STALENESS", "START", "STARTING", "STATISTICS", "STATS", "STATS_AUTO_RECALC", "STATS_BUCKETS", "STATS_COL_CHOICE", "STATS_COL_LIST", "STATS_EXTENDED", "STATS_HEALTHY", "STATS_HISTOGRAMS", "STATS_META", "STATS_OPTIONS", "STATS_PERSISTENT", "STATS_SAMPLE_PAGES", "STATS_SAMPLE_RATE", "STATS_TOPN", "STATUS", "STD", "STDDEV", "STDDEV_POP", "STDDEV_SAMP", "STOP", "STORAGE", "STORED", "STRAIGHT_JOIN", "STRICT", "STRICT_FORMAT", "STRONG", "SUBDATE", "SUBJECT", "SUBPARTITION", "SUBPARTITIONS", "SUBSTRING", "SUM", "SUPER", "SWAPS", "SWITCHES", "SYSTEM", "SYSTEM_TIME", "TABLE", "TABLES", "TABLESAMPLE", "TABLESPACE", "TABLE_CHECKSUM", "TARGET", "TELEMETRY", "TELEMETRY_ID", "TEMPORARY", "TEMPTABLE", "TERMINATED", "TEXT", "THAN", "THEN", "TIDB", "TIFLASH", "TIKV_IMPORTER", "TIME", "TIMESTAMP", "TIMESTAMPADD", "TIMESTAMPDIFF", "TINYBLOB", "TINYINT", "TINYTEXT", "TLS", "TO", "TOKUDB_DEFAULT", "TOKUDB_FAST", "TOKUDB_LZMA", "TOKUDB_QUICKLZ", "TOKUDB_SMALL", "TOKUDB_SNAPPY", "TOKUDB_UNCOMPRESSED", "TOKUDB_ZLIB", "TOP", "TOPN", "TRACE", "TRADITIONAL", "TRAILING", "TRANSACTION", "TRIGGER", "TRIGGERS", "TRIM", "TRUE", "TRUE_CARD_COST", "TRUNCATE", "TYPE", "UNBOUNDED", "UNCOMMITTED", "UNDEFINED", "UNICODE", "UNION", "UNIQUE", "UNKNOWN", "UNLOCK", "UNSIGNED", "USAGE", "USE", "USER", "USING", "UTC_DATE", "UTC_TIME", "UTC_TIMESTAMP", "VALIDATION", "VALUE", "VALUES", "VARBINARY", "VARCHAR", "VARCHARACTER", "VARIABLES", "VARIANCE", "VARYING", "VAR_POP", "VAR_SAMP", "VERBOSE", "VIEW", "VIRTUAL", "VISIBLE", "VOTER", "VOTERS", "VOTER_CONSTRAINTS", "WAIT", "WARNINGS", "WEEK", "WEIGHT_STRING", "WHEN", "WIDTH", "WINDOW", "WITH", "WITHOUT", "WRITE", "X509", "XOR", "YEAR", "YEAR_MONTH", "ZEROFILL", ] functions = [ "AVG", "CONCAT", "COUNT", "DISTINCT", "FIRST", "FORMAT", "FROM_UNIXTIME", "LAST", "LCASE", "LEN", "MAX", "MID", "MIN", "NOW", "ROUND", "SUM", "TOP", "UCASE", "UNIX_TIMESTAMP", ] # https://docs.pingcap.com/tidb/dev/tidb-functions tidb_functions = [ "TIDB_BOUNDED_STALENESS", "TIDB_DECODE_KEY", "TIDB_DECODE_PLAN", "TIDB_IS_DDL_OWNER", "TIDB_PARSE_TSO", "TIDB_VERSION", "TIDB_DECODE_SQL_DIGESTS", "VITESS_HASH", "TIDB_SHARD", ] show_items: list[Completion] = [] change_items = [ "MASTER_BIND", "MASTER_HOST", "MASTER_USER", "MASTER_PASSWORD", "MASTER_PORT", "MASTER_CONNECT_RETRY", "MASTER_HEARTBEAT_PERIOD", "MASTER_LOG_FILE", "MASTER_LOG_POS", "RELAY_LOG_FILE", "RELAY_LOG_POS", "MASTER_SSL", "MASTER_SSL_CA", "MASTER_SSL_CAPATH", "MASTER_SSL_CERT", "MASTER_SSL_KEY", "MASTER_SSL_CIPHER", "MASTER_SSL_VERIFY_SERVER_CERT", "IGNORE_SERVER_IDS", ] users: list[str] = [] def __init__( self, smart_completion: bool = True, supported_formats: tuple = (), keyword_casing: str = "auto", ) -> None: super(self.__class__, self).__init__() self.smart_completion = smart_completion self.reserved_words = set() for x in self.keywords: self.reserved_words.update(x.split()) self.name_pattern = re.compile(r"^[_a-z][_a-z0-9\$]*$") self.special_commands: list[str] = [] self.table_formats = supported_formats if keyword_casing not in ("upper", "lower", "auto"): keyword_casing = "auto" self.keyword_casing = keyword_casing self.reset_completions() def escape_name(self, name: str) -> str: if name and ((not self.name_pattern.match(name)) or (name.upper() in self.reserved_words) or (name.upper() in self.functions)): name = f'`{name}`' return name def unescape_name(self, name: str) -> str: """Unquote a string.""" if name and name[0] == '"' and name[-1] == '"': name = name[1:-1] return name def escaped_names(self, names: Collection[str]) -> list[str]: return [self.escape_name(name) for name in names] def extend_special_commands(self, special_commands: list[str]) -> None: # Special commands are not part of all_completions since they can only # be at the beginning of a line. self.special_commands.extend(special_commands) def extend_database_names(self, databases: list[str]) -> None: self.databases.extend(databases) def extend_keywords(self, keywords: list[str], replace: bool = False) -> None: if replace: self.keywords = keywords else: self.keywords.extend(keywords) self.all_completions.update(keywords) def extend_show_items(self, show_items: Iterable[tuple]) -> None: for show_item in show_items: self.show_items.extend(show_item) self.all_completions.update(show_item) def extend_change_items(self, change_items: Iterable[tuple]) -> None: for change_item in change_items: self.change_items.extend(change_item) self.all_completions.update(change_item) def extend_users(self, users: Iterable[tuple]) -> None: for user in users: self.users.extend(user) self.all_completions.update(user) def extend_schemata(self, schema: str | None) -> None: if schema is None: return metadata = self.dbmetadata["tables"] metadata[schema] = {} # dbmetadata.values() are the 'tables' and 'functions' dicts for metadata in self.dbmetadata.values(): metadata[schema] = {} self.all_completions.update(schema) def extend_relations(self, data: list[tuple[str, str]], kind: Literal['tables', 'views']) -> None: """Extend metadata for tables or views :param data: list of (rel_name, ) tuples :param kind: either 'tables' or 'views' :return: """ data_ll = [self.escaped_names(d) for d in data] # dbmetadata['tables'][$schema_name][$table_name] should be a list of # column names. Default to an asterisk metadata = self.dbmetadata[kind] for relname in data_ll: try: metadata[self.dbname][relname[0]] = ["*"] except KeyError: _logger.error("%r %r listed in unrecognized schema %r", kind, relname[0], self.dbname) self.all_completions.add(relname[0]) def extend_columns(self, column_data: list[tuple[str, str]], kind: Literal['tables', 'views']) -> None: """Extend column metadata :param column_data: list of (rel_name, column_name) tuples :param kind: either 'tables' or 'views' :return: """ column_data_ll = [self.escaped_names(d) for d in column_data] metadata = self.dbmetadata[kind] for relname, column in column_data_ll: if relname not in metadata[self.dbname]: _logger.error("relname '%s' was not found in db '%s'", relname, self.dbname) # this could happen back when the completer populated via two calls: # SHOW TABLES then SELECT table_name, column_name from information_schema.columns # it's a slight race, but much more likely on Vitess picking random shards for each. # see discussion in https://github.com/dbcli/mycli/pull/1182 (tl;dr - let's keep it) continue metadata[self.dbname][relname].append(column) self.all_completions.add(column) def extend_functions(self, func_data: list[str] | Generator[tuple[str, str]], builtin: bool = False) -> None: # if 'builtin' is set this is extending the list of builtin functions if builtin: if isinstance(func_data, list): self.functions.extend(func_data) return # 'func_data' is a generator object. It can throw an exception while # being consumed. This could happen if the user has launched the app # without specifying a database name. This exception must be handled to # prevent crashing. try: func_data_ll = [self.escaped_names(d) for d in func_data] except Exception: func_data_ll = [] # dbmetadata['functions'][$schema_name][$function_name] should return # function metadata. metadata = self.dbmetadata["functions"] for func in func_data_ll: metadata[self.dbname][func[0]] = None self.all_completions.add(func[0]) def set_dbname(self, dbname: str | None) -> None: self.dbname = dbname or '' def reset_completions(self) -> None: self.databases: list[str] = [] self.users: list[str] = [] self.show_items: list[Completion] = [] self.dbname = "" self.dbmetadata: dict[str, Any] = {"tables": {}, "views": {}, "functions": {}} self.all_completions = set(self.keywords + self.functions) @staticmethod def find_matches( text: str, collection: Collection, start_only: bool = False, fuzzy: bool = True, casing: str | None = None, ) -> Generator[Completion, None, None]: """Find completion matches for the given text. Given the user's input text and a collection of available completions, find completions matching the last word of the text. If `start_only` is True, the text will match an available completion only at the beginning. Otherwise, a completion is considered a match if the text appears anywhere within it. yields prompt_toolkit Completion instances for any matches found in the collection of available completions. """ last = last_word(text, include="most_punctuations") text = last.lower() completions = [] if fuzzy: regex = ".*?".join(map(re.escape, text)) pat = re.compile(f'({regex})') for item in collection: r = pat.search(item.lower()) if r: completions.append((len(r.group()), r.start(), item)) else: match_end_limit = len(text) if start_only else None for item in collection: match_point = item.lower().find(text, 0, match_end_limit) if match_point >= 0: completions.append((len(text), match_point, item)) if casing == "auto": casing = "lower" if last and last[-1].islower() else "upper" def apply_case(kw: str) -> str: if casing == "upper": return kw.upper() return kw.lower() return (Completion(z if casing is None else apply_case(z), -len(text)) for x, y, z in completions) def get_completions( self, document: Document, complete_event: CompleteEvent | None, smart_completion: bool | None = None, ) -> Iterable[Completion]: word_before_cursor = document.get_word_before_cursor(WORD=True) if smart_completion is None: smart_completion = self.smart_completion # If smart_completion is off then match any word that starts with # 'word_before_cursor'. if not smart_completion: return self.find_matches(word_before_cursor, self.all_completions, start_only=True, fuzzy=False) completions: list[Completion] = [] suggestions = suggest_type(document.text, document.text_before_cursor) for suggestion in suggestions: _logger.debug("Suggestion type: %r", suggestion["type"]) if suggestion["type"] == "column": tables = suggestion["tables"] _logger.debug("Completion column scope: %r", tables) scoped_cols = self.populate_scoped_cols(tables) if suggestion.get("drop_unique"): # drop_unique is used for 'tb11 JOIN tbl2 USING (...' # which should suggest only columns that appear in more than # one table scoped_cols = [col for (col, count) in Counter(scoped_cols).items() if count > 1 and col != "*"] cols = self.find_matches(word_before_cursor, scoped_cols) completions.extend(cols) elif suggestion["type"] == "function": # suggest user-defined functions using substring matching funcs = self.populate_schema_objects(suggestion["schema"], "functions") user_funcs = self.find_matches(word_before_cursor, funcs) completions.extend(user_funcs) # suggest hardcoded functions using startswith matching only if # there is no schema qualifier. If a schema qualifier is # present it probably denotes a table. # eg: SELECT * FROM users u WHERE u. if not suggestion["schema"]: predefined_funcs = self.find_matches( word_before_cursor, self.functions, start_only=True, fuzzy=False, casing=self.keyword_casing ) completions.extend(predefined_funcs) elif suggestion["type"] == "table": tables = self.populate_schema_objects(suggestion["schema"], "tables") tables_m = self.find_matches(word_before_cursor, tables) completions.extend(tables_m) elif suggestion["type"] == "view": views = self.populate_schema_objects(suggestion["schema"], "views") views_m = self.find_matches(word_before_cursor, views) completions.extend(views_m) elif suggestion["type"] == "alias": aliases = suggestion["aliases"] aliases_m = self.find_matches(word_before_cursor, aliases) completions.extend(aliases_m) elif suggestion["type"] == "database": dbs_m = self.find_matches(word_before_cursor, self.databases) completions.extend(dbs_m) elif suggestion["type"] == "keyword": keywords_m = self.find_matches(word_before_cursor, self.keywords, casing=self.keyword_casing) completions.extend(keywords_m) elif suggestion["type"] == "show": show_items_m = self.find_matches( word_before_cursor, self.show_items, start_only=False, fuzzy=True, casing=self.keyword_casing ) completions.extend(show_items_m) elif suggestion["type"] == "change": change_items_m = self.find_matches(word_before_cursor, self.change_items, start_only=False, fuzzy=True) completions.extend(change_items_m) elif suggestion["type"] == "user": users_m = self.find_matches(word_before_cursor, self.users, start_only=False, fuzzy=True) completions.extend(users_m) elif suggestion["type"] == "special": special_m = self.find_matches(word_before_cursor, self.special_commands, start_only=True, fuzzy=False) completions.extend(special_m) elif suggestion["type"] == "favoritequery": if hasattr(FavoriteQueries, 'instance') and hasattr(FavoriteQueries.instance, 'list'): queries_m = self.find_matches(word_before_cursor, FavoriteQueries.instance.list(), start_only=False, fuzzy=True) completions.extend(queries_m) elif suggestion["type"] == "table_format": formats_m = self.find_matches(word_before_cursor, self.table_formats) completions.extend(formats_m) elif suggestion["type"] == "file_name": file_names_m = self.find_files(word_before_cursor) completions.extend(file_names_m) elif suggestion["type"] == "llm": if not word_before_cursor: tokens = document.text.split()[1:] else: tokens = document.text.split()[1:-1] possible_entries = llm.get_completions(tokens) subcommands_m = self.find_matches( word_before_cursor, possible_entries, start_only=False, fuzzy=True, ) completions.extend(subcommands_m) return completions def find_files(self, word: str) -> Generator[Completion, None, None]: """Yield matching directory or file names. :param word: :return: iterable """ base_path, last_path, position = parse_path(word) paths = suggest_path(word) for name in sorted(paths): suggestion = complete_path(name, last_path) if suggestion: yield Completion(suggestion, position) def populate_scoped_cols(self, scoped_tbls: list[tuple[str | None, str, str | None]]) -> list[str]: """Find all columns in a set of scoped_tables :param scoped_tbls: list of (schema, table, alias) tuples :return: list of column names """ columns = [] meta = self.dbmetadata for tbl in scoped_tbls: # A fully qualified schema.relname reference or default_schema # DO NOT escape schema names. schema = tbl[0] or self.dbname relname = tbl[1] escaped_relname = self.escape_name(tbl[1]) # We don't know if schema.relname is a table or view. Since # tables and views cannot share the same name, we can check one # at a time try: columns.extend(meta["tables"][schema][relname]) # Table exists, so don't bother checking for a view continue except KeyError: try: columns.extend(meta["tables"][schema][escaped_relname]) # Table exists, so don't bother checking for a view continue except KeyError: pass try: columns.extend(meta["views"][schema][relname]) except KeyError: pass return columns def populate_schema_objects(self, schema: str | None, obj_type: str) -> list[str]: """Returns list of tables or functions for a (optional) schema""" metadata = self.dbmetadata[obj_type] schema = schema or self.dbname try: objects = metadata[schema].keys() except KeyError: # schema doesn't exist objects = [] return objects ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/mycli/sqlexecute.py0000644000175100017510000004271615101406164016241 0ustar00runnerrunnerfrom __future__ import annotations import datetime import enum import logging import re import ssl from typing import Any, Generator, Iterable import pymysql from pymysql.connections import Connection from pymysql.constants import FIELD_TYPE from pymysql.converters import conversions, convert_date, convert_datetime, convert_timedelta, decoders from pymysql.cursors import Cursor from mycli.packages.special import iocommands from mycli.packages.special.main import CommandNotFound, execute try: import paramiko # noqa: F401 import sshtunnel except ImportError: pass _logger = logging.getLogger(__name__) FIELD_TYPES = decoders.copy() FIELD_TYPES.update({FIELD_TYPE.NULL: type(None)}) ERROR_CODE_ACCESS_DENIED = 1045 class ServerSpecies(enum.Enum): MySQL = "MySQL" MariaDB = "MariaDB" Percona = "Percona" TiDB = "TiDB" Unknown = "Unknown" class ServerInfo: def __init__(self, species: ServerSpecies | None, version_str: str) -> None: self.species = species self.version_str = version_str self.version = self.calc_mysql_version_value(version_str) @staticmethod def calc_mysql_version_value(version_str: str) -> int: if not version_str or not isinstance(version_str, str): return 0 try: major, minor, patch = version_str.split(".") except ValueError: return 0 else: return int(major) * 10_000 + int(minor) * 100 + int(patch) @classmethod def from_version_string(cls, version_string: str) -> ServerInfo: if not version_string: return cls(ServerSpecies.MySQL, "") re_species = ( (r"(?P[0-9\.]+)-MariaDB", ServerSpecies.MariaDB), (r"[0-9\.]*-TiDB-v(?P[0-9\.]+)-?(?P[a-z0-9\-]*)", ServerSpecies.TiDB), (r"(?P[0-9\.]+)[a-z0-9]*-(?P[0-9]+$)", ServerSpecies.Percona), (r"(?P[0-9\.]+)[a-z0-9]*-(?P[A-Za-z0-9_]+)", ServerSpecies.MySQL), ) for regexp, species in re_species: match = re.search(regexp, version_string) if match is not None: parsed_version = match.group("version") detected_species = species break else: detected_species = ServerSpecies.MySQL parsed_version = "" return cls(detected_species, parsed_version) def __str__(self) -> str: if self.species: return f"{self.species.value} {self.version_str}" else: return self.version_str class SQLExecute: databases_query = """SHOW DATABASES""" tables_query = """SHOW TABLES""" show_candidates_query = '''SELECT name from mysql.help_topic WHERE name like "SHOW %"''' users_query = """SELECT CONCAT("'", user, "'@'",host,"'") FROM mysql.user""" functions_query = '''SELECT ROUTINE_NAME FROM INFORMATION_SCHEMA.ROUTINES WHERE ROUTINE_TYPE="FUNCTION" AND ROUTINE_SCHEMA = "%s"''' table_columns_query = """select TABLE_NAME, COLUMN_NAME from information_schema.columns where table_schema = '%s' order by table_name,ordinal_position""" now_query = """SELECT NOW()""" def __init__( self, database: str | None, user: str | None, password: str | None, host: str | None, port: int | None, socket: str | None, charset: str | None, local_infile: bool | None, ssl: dict[str, Any] | None, ssh_user: str | None, ssh_host: str | None, ssh_port: int | None, ssh_password: str | None, ssh_key_filename: str | None, init_command: str | None = None, ) -> None: self.dbname = database self.user = user self.password = password self.host = host self.port = port self.socket = socket self.charset = charset self.local_infile = local_infile self.ssl = ssl self.server_info: ServerInfo | None = None self.connection_id: int | None = None self.ssh_user = ssh_user self.ssh_host = ssh_host self.ssh_port = ssh_port self.ssh_password = ssh_password self.ssh_key_filename = ssh_key_filename self.init_command = init_command self.conn: Connection | None = None self.connect() def connect( self, database: str | None = None, user: str | None = None, password: str | None = None, host: str | None = None, port: int | None = None, socket: str | None = None, charset: str | None = None, local_infile: bool | None = None, ssl: dict[str, Any] | None = None, ssh_host: str | None = None, ssh_port: int | None = None, ssh_user: str | None = None, ssh_password: str | None = None, ssh_key_filename: str | None = None, init_command: str | None = None, ): db = database if database is not None else self.dbname user = user if user is not None else self.user password = password if password is not None else self.password host = host if host is not None else self.host port = port if port is not None else self.port socket = socket if socket is not None else self.socket charset = charset if charset is not None else self.charset local_infile = local_infile if local_infile is not None else self.local_infile ssl = ssl if ssl is not None else self.ssl ssh_user = ssh_user if ssh_user is not None else self.ssh_user ssh_host = ssh_host if ssh_host is not None else self.ssh_host ssh_port = ssh_port if ssh_port is not None else self.ssh_port ssh_password = ssh_password if ssh_password is not None else self.ssh_password ssh_key_filename = ssh_key_filename if ssh_key_filename is not None else self.ssh_key_filename init_command = init_command if init_command is not None else self.init_command _logger.debug( "Connection DB Params: \n" "\tdatabase: %r" "\tuser: %r" "\thost: %r" "\tport: %r" "\tsocket: %r" "\tcharset: %r" "\tlocal_infile: %r" "\tssl: %r" "\tssh_user: %r" "\tssh_host: %r" "\tssh_port: %r" "\tssh_password: %r" "\tssh_key_filename: %r" "\tinit_command: %r", db, user, host, port, socket, charset, local_infile, ssl, ssh_user, ssh_host, ssh_port, ssh_password, ssh_key_filename, init_command, ) conv = conversions.copy() conv.update({ FIELD_TYPE.TIMESTAMP: lambda obj: (convert_datetime(obj) or obj), FIELD_TYPE.DATETIME: lambda obj: (convert_datetime(obj) or obj), FIELD_TYPE.TIME: lambda obj: (convert_timedelta(obj) or obj), FIELD_TYPE.DATE: lambda obj: (convert_date(obj) or obj), }) defer_connect = False if ssh_host: defer_connect = True client_flag = pymysql.constants.CLIENT.INTERACTIVE if init_command and len(list(iocommands.split_queries(init_command))) > 1: client_flag |= pymysql.constants.CLIENT.MULTI_STATEMENTS ssl_context = None if ssl: ssl_context = self._create_ssl_ctx(ssl) conn = pymysql.connect( database=db, user=user, password=password or '', host=host, port=port or 0, unix_socket=socket, use_unicode=True, charset=charset or '', autocommit=True, client_flag=client_flag, local_infile=local_infile or False, conv=conv, ssl=ssl_context, # type: ignore[arg-type] program_name="mycli", defer_connect=defer_connect, init_command=init_command or None, ) # type: ignore[misc] if ssh_host: ##### paramiko.Channel is a bad socket implementation overall if you want SSL through an SSH tunnel ##### # instead let's open a tunnel and rewrite host:port to local bind try: chan = sshtunnel.SSHTunnelForwarder( (ssh_host, ssh_port), ssh_username=ssh_user, ssh_pkey=ssh_key_filename, ssh_password=ssh_password, remote_bind_address=(host, port), ) chan.start() conn.host = chan.local_bind_host conn.port = chan.local_bind_port conn.connect() except Exception as e: raise e if self.conn is not None: try: self.conn.close() except pymysql.err.Error: pass self.conn = conn # Update them after the connection is made to ensure that it was a # successful connection. self.dbname = db self.user = user self.password = password self.host = host self.port = port self.socket = socket self.charset = charset self.ssl = ssl self.init_command = init_command # retrieve connection id self.reset_connection_id() self.server_info = ServerInfo.from_version_string(conn.server_version) # type: ignore[attr-defined] def run(self, statement: str) -> Generator[tuple, None, None]: """Execute the sql in the database and return the results. The results are a list of tuples. Each tuple has 4 values (title, rows, headers, status). """ # Remove spaces and EOL statement = statement.strip() if not statement: # Empty string yield (None, None, None, None) # Split the sql into separate queries and run each one. # Unless it's saving a favorite query, in which case we # want to save them all together. if statement.startswith("\\fs"): components: Iterable[str] = [statement] else: components = iocommands.split_queries(statement) for sql in components: # \G is treated specially since we have to set the expanded output. if sql.endswith("\\G"): iocommands.set_expanded_output(True) sql = sql[:-2].strip() # \g is treated specially since we might want collapsed output when # auto vertical output is enabled elif sql.endswith('\\g'): iocommands.set_expanded_output(False) iocommands.set_forced_horizontal_output(True) sql = sql[:-2].strip() assert isinstance(self.conn, Connection) cur = self.conn.cursor() try: # Special command _logger.debug("Trying a dbspecial command. sql: %r", sql) for result in execute(cur, sql): yield result except CommandNotFound: # Regular SQL _logger.debug("Regular sql statement. sql: %r", sql) cur.execute(sql) while True: yield self.get_result(cur) # PyMySQL returns an extra, empty result set with stored # procedures. We skip it (rowcount is zero and no # description). if not cur.nextset() or (not cur.rowcount and cur.description is None): break def get_result(self, cursor: Cursor) -> tuple: """Get the current result's data from the cursor.""" title = headers = None # cursor.description is not None for queries that return result sets, # e.g. SELECT or SHOW. if cursor.description: headers = [x[0] for x in cursor.description] plural = '' if cursor.rowcount == 1 else 's' status = f'{cursor.rowcount} row{plural} in set' else: _logger.debug("No rows in result.") plural = '' if cursor.rowcount == 1 else 's' status = f'Query OK, {cursor.rowcount} row{plural} affected' return (title, cursor if cursor.description else None, headers, status) def tables(self) -> Generator[tuple[str], None, None]: """Yields table names""" assert isinstance(self.conn, Connection) with self.conn.cursor() as cur: _logger.debug("Tables Query. sql: %r", self.tables_query) cur.execute(self.tables_query) for row in cur: yield row def table_columns(self) -> Generator[tuple[str, str], None, None]: """Yields (table name, column name) pairs""" assert isinstance(self.conn, Connection) with self.conn.cursor() as cur: _logger.debug("Columns Query. sql: %r", self.table_columns_query) cur.execute(self.table_columns_query % self.dbname) for row in cur: yield row def databases(self) -> list[str]: assert isinstance(self.conn, Connection) with self.conn.cursor() as cur: _logger.debug("Databases Query. sql: %r", self.databases_query) cur.execute(self.databases_query) return [x[0] for x in cur.fetchall()] def functions(self) -> Generator[tuple[str, str], None, None]: """Yields tuples of (schema_name, function_name)""" assert isinstance(self.conn, Connection) with self.conn.cursor() as cur: _logger.debug("Functions Query. sql: %r", self.functions_query) cur.execute(self.functions_query % self.dbname) for row in cur: yield row def show_candidates(self) -> Generator[tuple, None, None]: assert isinstance(self.conn, Connection) with self.conn.cursor() as cur: _logger.debug("Show Query. sql: %r", self.show_candidates_query) try: cur.execute(self.show_candidates_query) except pymysql.DatabaseError as e: _logger.error("No show completions due to %r", e) yield () else: for row in cur: yield (row[0].split(None, 1)[-1],) def users(self) -> Generator[tuple, None, None]: assert isinstance(self.conn, Connection) with self.conn.cursor() as cur: _logger.debug("Users Query. sql: %r", self.users_query) try: cur.execute(self.users_query) except pymysql.DatabaseError as e: _logger.error("No user completions due to %r", e) yield () else: for row in cur: yield row def now(self) -> datetime.datetime: assert isinstance(self.conn, Connection) with self.conn.cursor() as cur: _logger.debug("Now Query. sql: %r", self.now_query) cur.execute(self.now_query) if one := cur.fetchone(): return one[0] else: return datetime.datetime.now() def get_connection_id(self) -> int | None: if not self.connection_id: self.reset_connection_id() return self.connection_id def reset_connection_id(self) -> None: # Remember current connection id _logger.debug("Get current connection id") try: res = self.run("select connection_id()") for _title, cur, _headers, _status in res: self.connection_id = cur.fetchone()[0] except Exception as e: # See #1054 self.connection_id = -1 _logger.error("Failed to get connection id: %s", e) else: _logger.debug("Current connection id: %s", self.connection_id) def change_db(self, db: str) -> None: assert isinstance(self.conn, Connection) self.conn.select_db(db) self.dbname = db def _create_ssl_ctx(self, sslp: dict) -> ssl.SSLContext: ca = sslp.get("ca") capath = sslp.get("capath") hasnoca = ca is None and capath is None ctx = ssl.create_default_context(cafile=ca, capath=capath) ctx.check_hostname = not hasnoca and sslp.get("check_hostname", True) ctx.verify_mode = ssl.CERT_NONE if hasnoca else ssl.CERT_REQUIRED if "cert" in sslp: ctx.load_cert_chain(sslp["cert"], keyfile=sslp.get("key")) if "cipher" in sslp: ctx.set_ciphers(sslp["cipher"]) # raise this default to v1.1 or v1.2? ctx.minimum_version = ssl.TLSVersion.TLSv1 if "tls_version" in sslp: tls_version = sslp["tls_version"] if tls_version == "TLSv1": ctx.minimum_version = ssl.TLSVersion.TLSv1 ctx.maximum_version = ssl.TLSVersion.TLSv1 elif tls_version == "TLSv1.1": ctx.minimum_version = ssl.TLSVersion.TLSv1_1 ctx.maximum_version = ssl.TLSVersion.TLSv1_1 elif tls_version == "TLSv1.2": ctx.minimum_version = ssl.TLSVersion.TLSv1_2 ctx.maximum_version = ssl.TLSVersion.TLSv1_2 elif tls_version == "TLSv1.3": ctx.minimum_version = ssl.TLSVersion.TLSv1_3 ctx.maximum_version = ssl.TLSVersion.TLSv1_3 else: _logger.error("Invalid tls version: %s", tls_version) return ctx ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1762004092.2988172 mycli-1.41.0/mycli.egg-info/0000755000175100017510000000000015101406174015166 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004092.0 mycli-1.41.0/mycli.egg-info/PKG-INFO0000644000175100017510000001360615101406174016271 0ustar00runnerrunnerMetadata-Version: 2.4 Name: mycli Version: 1.41.0 Summary: CLI for MySQL Database. With auto-completion and syntax highlighting. Author-email: Mycli Core Team License-Expression: BSD-3-Clause Project-URL: homepage, http://mycli.net Requires-Python: >=3.10 Description-Content-Type: text/markdown License-File: LICENSE.txt License-File: AUTHORS.rst Requires-Dist: click<8.1.8,>=7.0 Requires-Dist: cryptography>=1.0.0 Requires-Dist: Pygments>=1.6 Requires-Dist: prompt_toolkit<4.0.0,>=3.0.6 Requires-Dist: PyMySQL>=0.9.2 Requires-Dist: sqlparse<0.6.0,>=0.3.0 Requires-Dist: sqlglot[rs]==27.* Requires-Dist: configobj>=5.0.5 Requires-Dist: cli_helpers[styles]>=2.7.0 Requires-Dist: pyperclip>=1.8.1 Requires-Dist: pycryptodomex Requires-Dist: pyfzf>=0.3.1 Provides-Extra: ssh Requires-Dist: paramiko; extra == "ssh" Requires-Dist: sshtunnel; extra == "ssh" Provides-Extra: llm Requires-Dist: llm>=0.19.0; extra == "llm" Requires-Dist: setuptools; extra == "llm" Requires-Dist: pip; extra == "llm" Provides-Extra: all Requires-Dist: mycli[ssh]; extra == "all" Requires-Dist: mycli[llm]; extra == "all" Provides-Extra: dev Requires-Dist: behave>=1.2.6; extra == "dev" Requires-Dist: coverage>=7.2.7; extra == "dev" Requires-Dist: mypy>=1.16.1; extra == "dev" Requires-Dist: pexpect>=4.9.0; extra == "dev" Requires-Dist: pytest>=7.4.4; extra == "dev" Requires-Dist: pytest-cov>=4.1.0; extra == "dev" Requires-Dist: tox>=4.8.0; extra == "dev" Requires-Dist: pdbpp>=0.10.3; extra == "dev" Requires-Dist: paramiko; extra == "dev" Requires-Dist: sshtunnel; extra == "dev" Requires-Dist: llm>=0.19.0; extra == "dev" Requires-Dist: setuptools; extra == "dev" Requires-Dist: pip; extra == "dev" Dynamic: license-file # mycli [![Build Status](https://github.com/dbcli/mycli/workflows/mycli/badge.svg)](https://github.com/dbcli/mycli/actions?query=workflow%3Amycli) A command line client for MySQL that can do auto-completion and syntax highlighting. Homepage: [http://mycli.net](http://mycli.net) Documentation: [http://mycli.net/docs](http://mycli.net/docs) ![Completion](screenshots/tables.png) ![CompletionGif](screenshots/main.gif) Postgres Equivalent: [http://pgcli.com](http://pgcli.com) Quick Start ----------- If you already know how to install Python packages, then you can install it via `pip`: You might need sudo on Linux. ```bash pip install -U 'mycli[all]' ``` or ```bash brew update && brew install mycli # Only on macOS ``` or ```bash sudo apt-get install mycli # Only on Debian or Ubuntu ``` ### Usage See ```bash mycli --help ``` Features -------- `mycli` is written using [prompt_toolkit](https://github.com/jonathanslenders/python-prompt-toolkit/). * Auto-completion as you type for SQL keywords as well as tables, views and columns in the database. * Syntax highlighting using Pygments. * Smart-completion (enabled by default) will suggest context-sensitive completion. - `SELECT * FROM ` will only show table names. - `SELECT * FROM users WHERE ` will only show column names. * Support for multiline queries. * Favorite queries with optional positional parameters. Save a query using `\fs alias query` and execute it with `\f alias` whenever you need. * Timing of sql statements and table rendering. * Config file is automatically created at ``~/.myclirc`` at first launch. * Log every query and its results to a file (disabled by default). * Pretty prints tabular data (with colors!) * Support for SSL connections * Shell-style trailing redirects with `$>`, `$>>` and `$|` operators. * Some features are only exposed as [key bindings](doc/key_bindings.rst) Contributions: -------------- If you're interested in contributing to this project, first of all I would like to extend my heartfelt gratitude. I've written a small doc to describe how to get this running in a development setup. https://github.com/dbcli/mycli/blob/main/CONTRIBUTING.md ## Additional Install Instructions: These are some alternative ways to install mycli that are not managed by our team but provided by OS package maintainers. These packages could be slightly out of date and take time to release the latest version. ### Arch, Manjaro You can install the mycli package available in the AUR: ``` yay -S mycli ``` ### Debian, Ubuntu On Debian, Ubuntu distributions, you can easily install the mycli package using apt: ``` sudo apt-get install mycli ``` ### Fedora Fedora has a package available for mycli, install it using dnf: ``` sudo dnf install mycli ``` ### Windows Follow the instructions on this blogpost: http://web.archive.org/web/20221006045208/https://www.codewall.co.uk/installing-using-mycli-on-windows/ ### Thanks: This project was funded through kickstarter. My thanks to the [backers](http://mycli.net/sponsors) who supported the project. A special thanks to [Jonathan Slenders](https://twitter.com/jonathan_s) for creating [Python Prompt Toolkit](http://github.com/jonathanslenders/python-prompt-toolkit), which is quite literally the backbone library, that made this app possible. Jonathan has also provided valuable feedback and support during the development of this app. [Click](http://click.pocoo.org/) is used for command line option parsing and printing error messages. Thanks to [PyMysql](https://github.com/PyMySQL/PyMySQL) for a pure python adapter to MySQL database. ### Compatibility Mycli is tested on macOS and Linux, and requires Python 3.10 or better. **Mycli is not tested on Windows**, but the libraries used in this app are Windows-compatible. This means it should work without any modifications. If you're unable to run it on Windows, please [file a bug](https://github.com/dbcli/mycli/issues/new). ### Configuration and Usage For more information on using and configuring mycli, [check out our documentation](http://mycli.net/docs). Common topics include: - [Configuring mycli](http://mycli.net/config) - [Using/Disabling the pager](http://mycli.net/pager) - [Syntax colors](http://mycli.net/syntax) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004092.0 mycli-1.41.0/mycli.egg-info/SOURCES.txt0000644000175100017510000000563715101406174017065 0ustar00runnerrunner.coveragerc .git-blame-ignore-revs .gitignore AUTHORS.rst CONTRIBUTING.md LICENSE.txt MANIFEST.in README.md SPONSORS.rst changelog.md pyproject.toml pytest.ini tox.ini .github/PULL_REQUEST_TEMPLATE.md .github/dependabot.yml .github/workflows/ci.yml .github/workflows/lint.yml .github/workflows/publish.yml .github/workflows/typecheck.yml doc/key_bindings.rst doc/llm.md mycli/AUTHORS mycli/SPONSORS mycli/__init__.py mycli/clibuffer.py mycli/clistyle.py mycli/clitoolbar.py mycli/compat.py mycli/completion_refresher.py mycli/config.py mycli/key_bindings.py mycli/lexer.py mycli/magic.py mycli/main.py mycli/myclirc mycli/sqlcompleter.py mycli/sqlexecute.py mycli.egg-info/PKG-INFO mycli.egg-info/SOURCES.txt mycli.egg-info/dependency_links.txt mycli.egg-info/entry_points.txt mycli.egg-info/requires.txt mycli.egg-info/top_level.txt mycli/packages/__init__.py mycli/packages/completion_engine.py mycli/packages/filepaths.py mycli/packages/hybrid_redirection.py mycli/packages/parseutils.py mycli/packages/prompt_utils.py mycli/packages/shortcuts.py mycli/packages/paramiko_stub/__init__.py mycli/packages/special/__init__.py mycli/packages/special/dbcommands.py mycli/packages/special/delimitercommand.py mycli/packages/special/favoritequeries.py mycli/packages/special/iocommands.py mycli/packages/special/llm.py mycli/packages/special/main.py mycli/packages/special/utils.py mycli/packages/tabular_output/__init__.py mycli/packages/tabular_output/sql_format.py mycli/packages/toolkit/__init__.py mycli/packages/toolkit/fzf.py mycli/packages/toolkit/history.py screenshots/main.gif screenshots/tables.png test/__init__.py test/conftest.py test/myclirc test/mylogin.cnf test/test.txt test/test_clistyle.py test/test_completion_engine.py test/test_completion_refresher.py test/test_config.py test/test_dbspecial.py test/test_llm_special.py test/test_main.py test/test_naive_completion.py test/test_parseutils.py test/test_plan.wiki test/test_prompt_utils.py test/test_smart_completion_public_schema_only.py test/test_special_iocommands.py test/test_sqlexecute.py test/test_tabular_output.py test/utils.py test/features/__init__.py test/features/auto_vertical.feature test/features/basic_commands.feature test/features/connection.feature test/features/crud_database.feature test/features/crud_table.feature test/features/db_utils.py test/features/environment.py test/features/fixture_utils.py test/features/iocommands.feature test/features/named_queries.feature test/features/specials.feature test/features/wrappager.py test/features/fixture_data/help.txt test/features/fixture_data/help_commands.txt test/features/steps/__init__.py test/features/steps/auto_vertical.py test/features/steps/basic_commands.py test/features/steps/connection.py test/features/steps/crud_database.py test/features/steps/crud_table.py test/features/steps/iocommands.py test/features/steps/named_queries.py test/features/steps/specials.py test/features/steps/utils.py test/features/steps/wrappers.py././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004092.0 mycli-1.41.0/mycli.egg-info/dependency_links.txt0000644000175100017510000000000115101406174021234 0ustar00runnerrunner ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004092.0 mycli-1.41.0/mycli.egg-info/entry_points.txt0000644000175100017510000000005115101406174020460 0ustar00runnerrunner[console_scripts] mycli = mycli.main:cli ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004092.0 mycli-1.41.0/mycli.egg-info/requires.txt0000644000175100017510000000074215101406174017571 0ustar00runnerrunnerclick<8.1.8,>=7.0 cryptography>=1.0.0 Pygments>=1.6 prompt_toolkit<4.0.0,>=3.0.6 PyMySQL>=0.9.2 sqlparse<0.6.0,>=0.3.0 sqlglot[rs]==27.* configobj>=5.0.5 cli_helpers[styles]>=2.7.0 pyperclip>=1.8.1 pycryptodomex pyfzf>=0.3.1 [all] mycli[ssh] mycli[llm] [dev] behave>=1.2.6 coverage>=7.2.7 mypy>=1.16.1 pexpect>=4.9.0 pytest>=7.4.4 pytest-cov>=4.1.0 tox>=4.8.0 pdbpp>=0.10.3 paramiko sshtunnel llm>=0.19.0 setuptools pip [llm] llm>=0.19.0 setuptools pip [ssh] paramiko sshtunnel ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004092.0 mycli-1.41.0/mycli.egg-info/top_level.txt0000644000175100017510000000000615101406174017714 0ustar00runnerrunnermycli ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/pyproject.toml0000644000175100017510000000503715101406164015277 0ustar00runnerrunner[project] name = "mycli" dynamic = ["version"] description = "CLI for MySQL Database. With auto-completion and syntax highlighting." readme = "README.md" requires-python = ">=3.10" license = "BSD-3-Clause" authors = [{ name = "Mycli Core Team", email = "mycli-dev@googlegroups.com" }] urls = { homepage = "http://mycli.net" } dependencies = [ "click >= 7.0,<8.1.8", "cryptography >= 1.0.0", "Pygments>=1.6", "prompt_toolkit>=3.0.6,<4.0.0", "PyMySQL >= 0.9.2", "sqlparse>=0.3.0,<0.6.0", "sqlglot[rs] == 27.*", "configobj >= 5.0.5", "cli_helpers[styles] >= 2.7.0", "pyperclip >= 1.8.1", "pycryptodomex", "pyfzf >= 0.3.1", ] [build-system] requires = ["setuptools>=64.0", "setuptools-scm>=8"] build-backend = "setuptools.build_meta" [tool.setuptools_scm] [project.optional-dependencies] ssh = ["paramiko", "sshtunnel"] llm = [ "llm>=0.19.0", "setuptools", # Required by llm commands to install models "pip", ] all = [ "mycli[ssh]", "mycli[llm]", ] dev = [ "behave>=1.2.6", "coverage>=7.2.7", "mypy>=1.16.1", "pexpect>=4.9.0", "pytest>=7.4.4", "pytest-cov>=4.1.0", "tox>=4.8.0", "pdbpp>=0.10.3", "paramiko", "sshtunnel", "llm>=0.19.0", "setuptools", # Required by llm commands to install models "pip", ] [project.scripts] mycli = "mycli.main:cli" [tool.setuptools.package-data] mycli = ["myclirc", "AUTHORS", "SPONSORS"] [tool.setuptools.packages.find] include = ["mycli*"] [tool.ruff] target-version = 'py39' line-length = 140 [tool.ruff.lint] select = ['A', 'B', 'I', 'E', 'W', 'F', 'C4', 'PIE', 'TID'] ignore = [ 'B005', # Multi-character strip() 'E401', # Multiple imports on one line 'E402', # Module level import not at top of file 'PIE808', # range() starting with 0 # https://docs.astral.sh/ruff/formatter/#conflicting-lint-rules 'E111', # indentation-with-invalid-multiple 'E114', # indentation-with-invalid-multiple-comment 'E117', # over-indented 'W191', # tab-indentation ] [tool.ruff.lint.isort] force-sort-within-sections = true known-first-party = ['mycli', 'test', 'steps'] [tool.ruff.lint.flake8-tidy-imports] ban-relative-imports = 'all' [tool.ruff.format] preview = true quote-style = 'preserve' exclude = ['build', 'mycli_dev'] [tool.mypy] pretty = true strict_equality = true ignore_missing_imports = true warn_unreachable = true warn_redundant_casts = true warn_no_return = true warn_unused_configs = true show_column_numbers = true exclude = ['^build/', '^dist/'] ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/pytest.ini0000644000175100017510000000010515101406164014403 0ustar00runnerrunner[pytest] addopts = --ignore=mycli/packages/paramiko_stub/__init__.py ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1762004092.2898173 mycli-1.41.0/screenshots/0000755000175100017510000000000015101406174014717 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/screenshots/main.gif0000644000175100017510000040012615101406164016334 0ustar00runnerrunnerGIF89a w! NETSCAPE2.0!, " 6&;#3 ">"*'6&&%1 :5#'2%323L-L.5J,;cBa7KX4MfEITK'E(I0 L5[*Q+W3 R9G,#F4'G74S:"S:2hh#e7 y,z8m:0B>BVG4pD eI*fG6kR.hU;pM-uH1vU8XXXENdIWcFZtW\dS\pT_xX_yGfxWbkZgt^s~mYKb\socOkbYygHtfY~t^eeeekwirwxjb|kvwskwww3X(!j`%] N&&2L@d1V$Ri!-@IE SӏVXk9njvۡЮCQdiвphB>- WPi$=HɄt(,C+/MAr<XK?\N?@*$| -¡p,/tqaJ,B4̳p2L_":-P.Pݐ<55jkP^]`9ϫEAg(ux oˉ0Foek>JS~nre Y? G"O+l78ު {!- &9alx'bvY;Lx\%7$phAC.ja"q -y |J„"lu()@HCF!#~LSSw&Y^myU?߀O6@-r] $9 }YrR &죇r7deÍ M$)+ I\e?QKR6Ԡ RVM=ph#AO'A)aV{*snxR3o)Lh*Y;1gCǼk!a,ećZH,s"C@ P Yf(zqq&@C9LxQ=Np (@7WzQ(LT j)6[ c D!Id !Iֆ8B*f#O{TAʢɕUR~ZԵFwoZپC6`+I@D1o8ժ dl~`8qj*Pj}q2AdhOǏL^1q#۷&!#L`1||Q!E)w["ֵށtwZ#曐 v-r_^-C ^%ڠS!H&W,(YUd3V z!ޱѩGxm#)Vʺ~?p+ R)(=T**W ˹F@ *RM-{.k#fj 4t+Jtŏ\/e}8'!1SyK` Vetq56N63]RcjPwNm{C`m$FhUr Z݂ז#T`D@!'!m~|]6&eY׭ig'\dUTHEpܺ/Ȥ'o)ˇ`|XPL7~46IW7];b3{Yv8]991ϗz{.Bc<Qzl_EB4!)$.|> dG@~cbQ50TGaA1ymY&g07mW=:瀋mg2.QgGDy!z3!{(D b(!{ WX;#T.;=x v?@W{fu4,38p |eX ْ AWYWt7Wp d3L'l*PH?vP}qs qЇX@@Cx ,OHeUf43+X2$q sevp(Ir#bbXH4$x `O`Ԁ8W(xw&1h$X (SX /hX q30 ',0# !PG_tG@:>>E!j3YmA /RpyD[3)>o^mf&H _ RQ'us#YÜι)^AYR5Ԝf9Bb2>tM'?`,1j[#Ach0&OqOLZ5JA*:P?P*6z#/Vx8ţ]'02RGr9uit>!A}DDj RjW6qmgb}jZ Q GaAPA*4 va':*J1`P1q1P!ڪ:Zzګ:ZzȚʺڬ:Zzؚںz*T*Jz( Pʬjbqz˪61!PKk ۰ + K!˱K# k%+$۲7-k"09˳8۳AB + L^*ZYJSޠ`Z{Wյ\akDQ;Y+_T˶iKk m+o[ckqsuy{f{ R+Է^w ۸붒[y۴]е 0 c+{+K뺵˻뻽KkKk˼ ˻۵++ۼ܋+[ZK۾# װ 3+{{[̿{$T!BjĊJ%J|(*,.02<4\6|8:<>@Bp ԣ;|v*-, o-:9` J#) 7 B&}Y 0C v,J ް)t Y p" }f%}2m[ aǺC=%=tKi@ @`aW5G]ޠ oM J ) ؄M{]׀=;mki}) lʤ}M@[ ϐb]g} *-ܸ]װۀ35͐ڢ-ڽ4fL׭m-~\ۜ@q] ]غk]mMvM=M@ i=0- N.QƋ7-\ +n- - ޫ:nl; P.A^DTP8 5)@8}[/~G~ƾH9Qް:H;=^ߴ ; ]x ,r|ކo\.4R-ض ):p"^a NͅC Nsޯ-%]9ـ[`-$!Xi-`>庮.:než?SIC~-qꎣ$`q|.,^?_ ?_=`uu- /$?~*߮&aJ 02K8vAujjB?/ |NoPG;R)/{\]^T_Z_oajk_gbAex[{w?[tKo|+}️/_;)OQ;k[??O__/oJrA++%ooos_O.9*="&~Q_V?$XA .dC%NXE5nG!E$YI)UdK1eΤYM9uOA%ZQI.eSQhK Dz'SaO 'XdېyeE-o/`eر+/ W, Ts^Θ&]s/Tyϊnuiܹ6-FI[lj0XI[8"( J0vAȕ?֭VWh`+!/h覫Nn@#/@@M7k\*A͵ 2od HśNbب f9Iy\qO" kn%%Jo ,zL( ,H${SH@%+[Cux@4P(uۋ]F=\0"ݳ:8ׅP CT:mt/t$&D!nԋEHν-S&y o&.8764g 9z AŁQTĮ6! G(:_ cX3KlH9~Yd>L@ HBѐ L*R#`ޑZ<$!R@ o f QM%X%)_e(KUUmL)"~&/5ӢAML t4L3Kf)5Sk%7oBS䬓9)'7r l',-zQ<%#74!#:D * p8 2^˓Nzq/W\ LF$RVsͯ2L@ieLRA.ULT_NSpC-HQT-? +"ҋU.Q:׈\,~Sd3QUa B"` X6Xlc; Y`E@0Ypv-,YYہmok[׷%nqG6Uq\FWӥnu{]fWnw]W%oy{^Weo{^Wo}{_D~_8FHFC &p"K@"^@p{X VF\b&q?k "VO۸41Yx>1\d"90d8RLe$OX~r__xBgq* h|Ф=3,gY gNL89p7c; Ѐ^}hF#щ3͌f57ϚV9MhO:ңv!]jQ;{ƴl_)uk@em-Z׺޵[:uGi=lu͟g+n6-^ڶ6MlYϺ6=sg.7ٝnf{;nv 5W7+N5Vad/߭|j(m'G<O ǃ\܅PJ^ܓ7#gy]r\3ym~s\;y}s]C'zэ~t']KHVLkL"(uNF6hY]Mj^#] pޮ 6@!I@N,&ĸ EW`'TŃa d#)jC^Fz-,#bj-oLGu\GvlGw|GxGyGzG{G|G}G~GG鐂ڡ .8 1,HHȉ,HlG8D`B PC&$WIHv&, ` <$,.2+Cǔ` [7ZJPJsJ\^Ӊ!ɄØP⨠<( EKu<J6`Bs jt!{[<` D8dA4M9=8(:::I0*(kdE#OP=?1(oh0X8˙NNU0OAO5 DHX#ca_=UEl94>B\/Qj12i3QPEP PUs,?4 ϰyQ-aﻞ`PJ#ɖYÅ0KR E@^ %IƄR)Rox,R .d\lQ@EYѾEN`4]A z/A6S-AљqHф8T0Q@TRTFMtA3AuR'*LћuʲG(Z0ͫ0OUZUQ\ZE]U/F1.O\=ދ &:Ͱ=#H>IZ>pO/([?VTb \06GvT EM=@[E6v: B$ё"#NYRlR=0-U\SR]_*;䤳XSS; y9A.~Tg TǡI}FETG]tPK}LEfOg)7PyfVN`n~eW&UU6UoU^M"y£"Vz!~&熉V VhmW#t $Pה~*tW^W7ϋ޹C3gP'|}5"HeUKBXGd؆X=؍}jψuj"qֹvˢ}(.ujY| Z\$`헝zm^Eڂh79Zkڼ~ڰOVtaZdۭ*[xWv^}*vkە.Mm~U}F{܋\8E]/(].n>nNn^nnn~n~nnnnn};܂~%^tSR.{ o땈{".;{o8/IV H~>wb龇~ n'qbl ?On w C q@0 ~  /G0*߈( q&W0Z"#OrR)3s0X)0~7@<;qAE#n: ؅{Ky!+~ ~hAJС灃8aࢃIoA6a?P7NLB }H _Ҡ@G^A ~:h҂+[P͜;Djϟ.=h@IRD 9.Iՠ6p]vy?lȒ'Sl2̚7s3ТG.LPua҃YSn'61;ᾁ{oM\88 yL׏Ͷ_sM8`9ڒ+cɷUJŞw`|djdœs_%R`6Yyͳ=Xiz!!8"%am8lZLU9nHF@7n>!?W] Qq@*` s6$5e=8֍JWLYO8Y \1 c U[?04F:v":(J:id`PO,Ћu5iS20B+tB1w3] @P_6tk? 1Geb@W}j?+%@UhpM#.|AA(#]UƬD(/ hOi0.+Zip өV-GO4ҕrT",vgñ #aJ@(רr][&<@gt*I:4觼Soe?";e}6iU?8jv-j?Uv@CŠAqy<@@UlݘR8x?@> [g~'yie &=K53~n^FÏ*XH= >k@TT.-rJ7I}L73@5f:cჃ $>tP_w1׏)_kL33ekZ1ߍ%(T~ V>.BgK .ak٫ SO}V"X6 A LOdH ̫`(@ e|QXFYqыxQ FY x$("ƃq9.pجMO%!t U"*SUO /LJ-rrUg20FQji~ z|%2en!3@33= TcIOmnj&8)Ubr 8VNs3H``2ҩ} Ё=(B'#Є2}(DR(F3эr(H/ ґ4&=)JS*".})LCJҙ6)N%ӝ>LiӡA`  *UT(TիN4K̠ձA-QӪֵaXc1F`\3um eYG2(]V3a s=< xkEv pe<Yjk&ұ-n;tF?~xG4 4֬-t+]Hq.r+qעpnF\Ҷ=/z;a nw+*\^4 QF;ޘW/+6mmkbFr */L skv/ע nd'_ c80cݏN eA%6yiK 7&D0rhE8GeW~x^GqKҗ<;hFh`sx + [kP4 qEQꍮ>,;j;hIaȾ6Hm6qc>7)Eu~7My7KC}7T ?8{(#.S~83*[?RTfU\+NTcu6T#Gb7~n@k5Oz?;L}߉͹'+le/;Zv6`'kyen78Շusm?zKߋrB0eQ~/wu]ZGF9]c]]Aaa}cGI8c4ydafq!k!;c8#@ ޟ_F_?r;$CR%F-dC^DmM$EbEbHảփM۩!G?$Lj m [KK$O`XGdO&eTAz`Q_!RVٰ=eFQU~%u QJKXnmja_?\Y$Z%^ :F me]%a1&fLyea6&i(fݥcNf@ J&ef&Xbf~p&y&hzꑦifá&R%kŹf¦laf&n&uQUm"ΉEqY6W#ofoٗ N @$ Q^)"cBgiU[NT!_v1=>"x~@yAzRT`Ug{^Y΢j}>~hg?`>Us"(k^?^=TT;Iw|(fI"!1^U'\qգ%x^芎gGS X1)qzdO}}(E՝\\ä %.&Suh ]r^VifbVi}̆x娜B)^ gzI\~^(:)&a)zZ]eٕ~{\)(i6^ʚSi*\'v2_6`jtV"bzn#f*$*֠R&+ֲF+ONkYU$nHvO}+^+CZc'E\P%d+@Jcȕ 9JDr})~UWhnTQejFA \)2+Îc~bZ.^9q:Bǎ,Z^%]_u˾,Fj()nξ0I{lmUE-<7<d-.LUԀÀ>C5ЎĕB\g'fm6/~1-{9 }".3'=vU۹=҅ԝ#n0#cFa$, c?PX .ju$HApޭF=_D(i61)eE pk15F ٗ 3cBpAJe1a% `vrG[3bDv r ^[!j>:Y\~.#>FK.*q'7#bo r*+2-2-w-C.?/!0+d/F2232W17s=34bocrZp&0VAs.p8YkUs15\  oHN.E!?0z0-=[F_'EIk{#@[@F"ڱ '>kDv蠡!s4o鰞qqAhI4`@]NfkKZT!0a(.q!_f@ .屢?8Mhy4Ta_OtF2Vs$z/LRCyŸQO{kP¡1 K^!_YoNJ56a\r#bvk4~{*jc5W/_`w8'7}8ŭS_#[6s7kqj3h8,oTj?3=3a.or5c.8A]E#"lJ'"UclgywkG~)rw48LGDִo) -_ڈ"_yQ-ߠX */cK:r1\{qU閭`/b3acg:7i)(:5H*c)iz}{-.v{BwQ?g7:#ۮw*?w~2_6gjj5#7VO%;x ;^|6 ;λ~Vja}i= gܕcA/>Z}ӗw|_ w(qz۽S[ԛ;uE=X9e_|FuV}W m^[T`t~!3Ȃ_F^QT[xk>kuz ~~7_>/gE)?vqc}5C}ý%3vPޒB'Wj?g~^kYS2FuO> 4xaB 6tbC0)V8qY9aCQF0]ٯ<(M^8K0tͻ#H4m4)hP5ziRK6ujTSVzϖ4o0s؋hZ\R+0/ΝYװ`Ɩ3.E`5|qbŋ7vrq՝˳fMF~CXr:[iMV:RVDۘ5OiУC7\\C%7wztөW77cڴLN{{ /0aC0$ D ,L]|eѠmuLqEi Hv<$p"|(Tp*Rܒ.*,J-<4D65圓:_|<}>PP>=D=F4tH%T`Ό53QK5/TS0ԿRRJmW6 #;c(ZiHx  5 YX*Xݬ5nVȸ W0Xr(J##}]cr)'Z v1R1 > ]cۂܽHl ;7G>U.ҭ %32Kb=9ZGfDvv夕^z:$AW, ޷JktEid~n #x [d_+>F4BKXG8p¨'0ԍ첿&-!LW%A`4d Y(X7 _Wt,k Kj-6{[ &gN|Zu ^p"z2| RED0a !\gtԒ7F7Nk#G;q@scG?:{$HCr1Td HG>2LIK^id*IO~r2JS(T`:JW ”8)R03+tsf0L[T%㲬jZ‹3}#Ci h0\2ɹLqu\җw,tzhB\єz)M +LK{).* z8M;{w,9 Ȼ'9?5>o=o<7oFFGs='s=  =5<v ?+ 7A ` : (dnG;qLa4O](`긁bDO  Fίϐ`N66.@4/А @L02~H/6d¯ϼށ0,іЈnLPЊڠ#Ӕn mM 8 .-Mlm800L49PPF 5.kMO qpҠPL t Bќ,Q 0  =ca zb4 TAPv@6 o1wRAؠ Lo-ސv[ !:@\)$Q5:n BpNp-#/ن B $Kr4 Ip2!2PϦ4`<' m1&}qφZ @a()qRϒ`~Fqґ 'L'%+ B!-?/:Qp "5RRS#aSwJvW5/W2KUWuTVJѬ-wWtO/AffkB,g(MaMAXh'5;{VfpShGpPV2,]57zr-8A؎,/mu@gaknGt٦FxTh/I/@4ST3B!$cŖcWqϰ.s57ژ3.7uH76uVв 7w!3 '@n77lxkdMѼvW\V2$DS{QW7'۷iBww>s~mU%?iՅEJ>oAÞMV瘍P`ۓ۞1n  ׵뾸?~>uK m5#" !,9  3$ 2"2(323I#M,I(.G2:e3PM!UE0iL)q]:~];BJPRLI^^]uZHqomvx{\~fz "#+$2"&,- $22;94:LIWYBFEHDHJRTX^YQ\WY[acimcjjwyFFJTSgehwþ[gmcfhuryryzvwy}R۟Ǽȼɼ̍ˎӍߗƙΒҝДݜ܇ǩɥԩҸֻըçϾõHp *\ȰÇ#JHq!‹*jȱG~IdɐM\!J-cT2̛85ɳ'VۅANHc 4MZ1vMJix0؀UvPkI+-EѦ-;F7n>\`#KXae X|Yq=Fl`` M#A%/v E PF%S&{w޾ȓ+_μС'Nzسkߞ׹Ow,'1$PQOG+OII YxpC1yԅל\qk`q`Lsr^a+xr$M 18̩1M3YQb1m؆yr7qLsL! nr qI$!"92 @Nr>~_*'FS344@ׁ%L`xˉ2MέfypbArx*fe"GB\Cʦ&ĘǨ{Jj.L j^J蕚:G\Ӡ]ѣA`ev-4bP+"ô2,z*JK)4+sbJ!:M4Fz+ vLE|:q"4+.&Br%b |^SP!3-(ߢʯȒ2,Ui) P1ƅ;+µ.EEzѫ"."Ykt;#ֺ c^'eyVpwqםnۭMg'q*,8+r^|\ {GCE ' qF G,\KRhq#dg F'v0B5 Mq\:ẻ4򊣎<5#)цq=҆-NqtT10K[2q5 'kB9׋C';k9ax-a gӘ_a}w3>xDu82d0d*F;?bDB)jT(qPɡMlQDr=V1Wr#ԸCdP!0& c|atwf=+ZԪVr E:u<Fx @0qd1Q\r0 W`rF2:O&9)qIK245F 8A29;Nzhg4C5bw0"djsd-d8YVNl$;+2H"q$ Q%DI#T%t rBƃ$=E1J4uaZ_ӘqhKҌtSkȑMiڜ XK9gt3Q7sSTRMj:6U nsOsAAZGC<ةCPB<ʵ#ǯGMzRT%b59 Iտr9!ln99!xXv9WH6 +tHG(u,YFEښVV:%0;u*fnY<'ӌk[fu9;%OSms˪vʣEEv)N˝V/E7Oz3Dl7Gus0q&L [ΰ7{ GL(NW0gL8αw@L"HN&;PL*[Xβ.{`L2hN6dpL:xγ>πMBЈNF;ѐ'MJ[Ҙδ7N{ӠGMRԨNWVհgMZ& !,Cd\1OBaQF0FexHfx~aOyhJ "+$2,-$22;9:LWYFHDHRTZQ]Y\beimcjjzFISgh[glcfupzyӧ{eǼʼʼ̍ˎԗƙΒҝДݜܟҩѠH *\ȰÇ#JT"3jbB Cr @$=ɲ%D}*P#Q%A+ק @ڄ f]`w#ĕP{>Lx&Md,/+ %E3A7N:MD-N*D1K5O;U6GHHJKYWFZP[\RjWqVx^rY|dNd]uZ{Zfweziptixd}j{pDLUG/ N'L)I0 W)]+U2 ^: md%`(j"i,d8 n3h9 {.r4t9~9|Bq~{qtz{-;:/789BDLR Z CMELQ[ PZGMSZS` db d MPSUbe ek kZ]hdjrtmltuH*$XÇ #JHŅ3ֺȱǏ 5BIF&"0( L.c9"M(3H%^Ŵi\J SJ*APmzaRZf2q iiAC\ Ɲ[.OL'pIK"͢*Ie7,.1hV Na)+ZFSn.M6ZuY0mDlycӚ=pbR OxGL%1P!C]{xLEMaӊUE`\' 7ս4qaQƒ y=XBѢeGѢ Ѷ}%$,"r؞ze$.܄XP'Lt#E#$P*@帤@)05 o8BbA0uH +V5d 䈔[|qʈWFX8VxMEzI@lE@v^ ]^0qY Iy J=ꫭkj뭸뮼믵B k,o  Hf[ nbmtCr G볻 CAeA6ԊzoAAA{\d. gQ0cQ+Jk\+h 8𑄴9D$|2+Jι"@E 53иPHt0F?19Izt2 lrIKM,m jЃc8AQ+]~ C 䢗tHy֚L?v 8l󺵯. G@.;e< A d*A 4?O0tfj9mNW"7r@ Z H8 @ x*߭4an ڰ7X"L ePY5Px!$,W+"323_"  %"*+;$,1!$,, $".*22;9<23:DLFITYBFFEMHDDHJQSX[YQ]TWY[adikcjjquzy|FFOJWRSfowþUZ[gflcdkusvyx{ryyzvwy9öǻȼɼʾ̍ʇЎӌڍߐėƟǚΒғ۝Еۛۜ܇ƩɥԠުӹöػտӽޠH)\Ç#JHł 3ȱǏ jlɓ\ɲG.DI&E8[)s͟@ oOAdpĞ>J5ӈPjYժʧ=UYǪXهimWa{?H ؖ`]q-L/ܼ4ȊqR70f-;&LҨ;_NZְ-Mڭ ͻ Nxpȓ+iУPN]sسk/^}9ᧈqpf[x?~{ݓ_n Sxwހ!7pƠWu `t:`xoy32oj8O:Xo/V)ijLras C- P!Ř䆻 ?d 97ᇾY2"\d:'> 즤Lv??Pq;4,HAY춋?Q ᒋ=i? ܕ<"*EϨ]10i (*Zĩ0*16I{g 9Ѝ?z%{FHZdo79M>.g;#RpT?~C"n@ζh9zFo*ȏHa^TCuLvtn"0K*E` o &GB~# IGNɒd0-M*&Ai)Oz2eGPYJQ~8CP&8rp|X@nn~<Sq$zlnj7›FQL!Jw:0(^'1Pك7zf|j#Jb}t"{S:B?ɛMKl\p,bpݍ?dl4eyo|o@җ %?;ꏏɛÚuu? zBȵP`׏ډ7pZK\e]pXiD NWPjmҩv.ULĪ,o?F7iP*>`~$-a00-aWs^g̙n_`6iϯ*7.,jܼ@(O}_;|f$lnY| 1l~JS,켉S{7w~EYoynnv]7snNaq&m t3Tb?@E)te O =겟i_w ޿*UΣK& 7 Y @e~_ː;V}85ȝ\79@q=#ٷtj{=# ? 9En2>f>/fN2wd\ȗe2W~a( 0 .>/X^tjO2VM'0*?5 s\b6is#[HuS<_Oԧ! 9AhAfxa)z8SrocPi(B,dRTוwBZ "S|8~?Cx^ǔQ[p[[&Zt.pERDEҙ{5]n8m` 3tX l^ ^ QP )뙔i1`aZڌ!Z#%'j|@l6a};cMFc5:'$C[]GUӡ'yXVhFiVz1;VcExRڞc=,yc#_ZE>n֘[3q~0EHˆbjKvؠ 0F9(nwrGwu4^zy`G  !y5)hz.7 |{ߪ{j{:{ {bjb+ڢK796@0zW;8:ԣ?v񯑨hai99K:*@oPp$;PeEN:j(mI3I`H0WA L V>HM U zC'0A:": Gs|̍ȔD(jȼBdEb@cgY 4~Uf?`fetIĻg%uvgY%I9%Ejvs]uݚoʍ=Uy_fQ}mo16ل ʂYڵ˰;Й|pѴFUrʌ/H9gc ځtXNɠpx%`'vW}F;S xWLMm=|V IO χLEbeF'gfvE|ב ɪRŦr}㼜̲-pTӍجGj#Rڅ t伈ۺM[>.q^~}q.Y0Yi)cAgAn)mJ\gޥ7}pMywbm֊ ;ƺ|ZJjZ9! ?,un+ !&!( +&(!3)":)$-iPV2K)iʇ|++˺rl-ۗ]%z)aӕl1);0`q3LScHpYf~a=8##?Ag:_N H+9#yR OxӟhcR@p'B]wM[PT2C щF1bQ~Bԣ5xt4'Eh@4j@-LMCS;RL؟qNqu!?CEÅ UI&"I#*BUд:+ZɨR"5[V+εWj+`*4s1t ؉TmTfub$gwIcXj(cc:8<!=zqbRQh$c`я8sƤ*]AAbD% 4VGs;JOU'ı c:uR!T"W2_N#* -dmLPgMb֛0/x_ s 9l8 +e6sp!sx+!6W78NJ1`.1ae0tIf ֨GEJT6@h%L}j֋ 4B^N(?@L&drvE9U.B#P̔C"k$7^,gdBFL~ hQZ)6dY/$5"g,t@tVjѥ~̔g$)4]EB@_dϦ)k\3~LG-3ed@EP cFۭǡJfƳь8>#ƲĮar,j0nhG변1^jJzsQR}jT% ߶kcN "VxѦŜ'Iɮ 7(=$m1t؝ܷE^ 0Y-ViճNs}[w g0;Yv0Vih8ֳz^[bZmK1o#W>1 @ ^ j.wc8u `Ax{0݃U$d,=zVBk4H!beF⿑79C`;xڥ_ňgAj} e'xom>2_r̘+4%xE `Tqf CJ`J_Gu W|RBdu X^с8 WcWvgv1:7rwsWwmTC?f w\}''wkD2mt"xgp&`Y@ (fa 2yH#&%"3ЅFnA&Pzg 10%n'(zrGk(rQ;{{*ytP1DRg|`-^o|} 0}r\}}_t"n?T<(8Cw6PWpjt^>F6HfH#،и8PӈШȍh=vw!r!rx#OVy"D'VfPnb)!X{QR+C|It-…/Hi0=v2$aToӣ4L4I5\5kmӎ=i$hBDJ8NHɓM%c({X{&H^gb  R ?@:",b[jy;lLBUنDPsR'C&_W*P)5rgg+)*2…b`)Rh'v C0c燒)c2,HR##"?3yi@+0^%e5QyxABdBwDy&#&*A@R熠w%~AMz8zRڣ9&OB*Đ:t{]ڇOa dY9|<9|LZ|$p=Ij}FvJN|} TEl4k_m(1x12m @ GbNT Sp ]P @+P n NZe55 :iVVT< Hџٞ+ N)iɬ yVu,ZUZ#(hGXɡh2StVzuS 0bf"v'jIJ$w@wAqtV^ՈE_ eSG, uU&E|`RDkAb|_53 4 2h+UAd)b-_c:X1#Ր=+a?k*)vdJV9&|p bQo gV KX[fgfRenf[$' 0E |lfesfoԶhhnp x up6s!(*7n5jfg#-Ԓ8$ pF}Fbi!;-1R l0\+A 0[Oz[@}x;~W<2.Kk񼟻AoFL0FKq'w6G4 ǤB,a RGw4蹇8s@Ǥק̅t6[KԺ֊L|૭ȭi¯I Z+؂/8:ѯ:X5уы J(L(m4̙1 aU"Z fch5mZtHI6hn 8!b_ZeIBjaloklX[],@F+=l(_3wq| l\ln:,"K,Hو)-|̊ıY 䑖weܞB n9!"2_(} h#賩|iOahb,\iBcPbY⚋);W%*2+goESowk\y.R\&4盎Q"0V"Tyű >3<>51pɆ96ˆpC& >)8@5˪(Ѧ R!,+ $("'''323P'gT;IIEIIIFdwHgxJhzwwwyxs %"**3=$&1"&,, $#,;:/4:FLIUZCFDHFBHJRRX]XQ\TW[bcicfmnccjkvvyFFOISYRgev½W[[mcdjiurvyx{rzzvwyΧz¸õȼȽʾ̍˂َҍߗƜΓ۝ВӖٜ܇ǩ̤ӪҸıֻեʧ̫ѮHp *\ȰÇ#JHŋ jǏ C1ȓ(S`˗ <͛+D0 Ο@Rl0ۃ QӧNZի5R퉵WZ3rJD%@Up$Q۱r%Kk؂x +~zxŐ68e̹&yLgҨSN:ְ1M{ڸ͛` Nȓ+_μsKسk߮|չO"p#"x߾ Gt@?>twFI@DF7Fh ]ő1O:vhG*Dw3(v!AV(#_`q1g< p4K!qG7dE\Lfy?gpSoXjiy\6<#Zx<I g] /r)fѨ~6*O/TZATˆ(Si/:*jwvRJ9ꫤpc7gީ$B$:Ϯ&+ܯ K* ͶG;n2;+㠇Cntf+7Yl/x ?,:υϊq,rl2p#wl*q~G$8G\ gۥqɿQ,'p%dp 1њ(͵1:LPKk0݁ &hەćuZ:\o ypg`zwZs]~\'guyK7º< AĔF*!OC6Ot}8U<s ɣKiSs4fo[|*%::+Z/ֵ1nM+\ֹcqHft *%<‹CDpD<YL,e#36v<ɴ8)E@EE`B_p: 'kAj<|sW6~<*GTVlx,@K.M\F6Q9z+6ɍn;N}r. .~P2}/y9S^j!)[uwN ~%L8P9q{w-Skȗ.rG4E|f9&[9k3$N<'X;SuXۜ7#P! Y(G8L_uHi`x 0_G7):tqVΓ]Èoy+n](X4bSg>cٖІzLSVxOsCJ|/8(!:ty'O}*m\| NntSCY[o!N*LQ{g TԝQmu;bKYd#NI%X0͗ݗ=d cXI'mW,&5p>q8mIhB:yS\FeJ vT8#iTSOEU6P'A"lTF~D␌}+\Sw[Rq +X~Z1!kJܺ)gZO,NT 2UX̀&4r8z^5'/y)hYhIv<򔟼1 @8 /ȫ4ttU % qnoDIBWS4Y9}{J]ǣsÏߔc/}h{*IT a0=i0 Y5I?rwTF IJ5[[qiq%] ƁZ +@ar]46KU^P^^6"u}06M@%Ng707P7u#I#8x:CGaFuaa{j3oCbQilL?:ZRd͔cMcxLFYb6ee ef:oWV448V)tg+4N+gavc 8t؊hV{aO7j)fT($vl–PXlPʆ\Vl؆eP縍H/m~ec͆QE$Q8fejxnnQ3pOo8ȋ,¡qppqӈˁppy8rR^؋s-wt7S1s5Q50r;ɒs0R{P":B-d/T h7sR*'p GaIFA*57ayW K r]T}ZV{iJjɭ=1S=SYJy x44hrB1bBJP)LFȅv8h$"`U#+Fn:ŔXP5{A#Qte#+!fmv;0gjOC#>+ izjOvjׯz'ˈk]zloi(:a ﺲ1FQ?6'ʶrV;J""4 wT-s jXt׶Zjӕan;.9vА vN𧬌VQ;|r=%!\ i Vz{U͓RK ;c{[n.4 )FP՜Dn96| + Ny#6;h9 P;LW= hjxBh *$lu}v85:7(HZhسMQ RX>]Z:lcZ/dtw#̾=) L,eK:sʩELM RתIǫX%2ܼ¬n:t~y~{|~}L~~}HYqZ_G`%U5*P&W+0|Ĝlpb妡,eQ,,A68;\kp&ʏ\DVp,e؈˔ee `IGz"EBizl;w%tEqesϋkU}uȝȣ%?3(\\0]@[ҝ 櫂5%1J,ˑ6`B^%yv")r.^F g@m̹|kb/fH[ƿ)'dg/թ<9kv8mfBBxMfwQ̢d(}d؉6tŜv״6$6m)jsM@mhvmCLppoco6 lgoM lgq!\ ӦϷ*i8)]\fm׷R(49wGl,#nGu]o"-@-rvBID]z|IgKnhy[$zS\Fz Nקm{ah{heˬˋ⣬H2>4^6~8:<>@B>D^F~HJLNPR>T^V~XZ\^`b>d^f~hjlnpr>t^v! ,%)2-+(-1$!!!323+L$2\0 &hCxVx&.!z(zP:!d Y%1^ј^rőWdqEU^pLLYYb@ŕ|TZd$)$zDHN+b@C+@f+Ge}H+h'}@w␭9}Jw:ޞQyWi(eQ bxl2 če'*,ytIR,w"樥`"%rj^".ީ2k/.苁G{ަv觭fz4+XJj:w.\)Bni *!L-6H2%vnjk&ؖƝ<#hM`'K+U7.Go6,@eF|P5ĝh2mu}u 4߀v}[5>䔣7gwgs'l6`7p(^ ?,9=N:桇rF+hЋBHɊ~yi$$څ@ H1\A' K^{vs B䆠淢D:'=ycbףT@$MGC;}y8 Jd)DN:Xp|seU+[JW 5k}8E#Zф wke j8i"Zh# 4{Sov+^Њ5'E  V$'E5a)j%X$feV2_ǐX0EάfD+f$8t+d֊M("ъE`o*dIX͎q.Y7hI9̄Ibp2D7M59k4gYN9rgIz̧>~ @JЂMBІ:D'JъZͨF7юz HGJҒ(MJWҖ0LgJӚ8ͩNwӞ@ PJԢHMRԦ:PTJժZXͪVծz` XJֲhMZֶp\J׺xͫ^׾ `KMb:d'KZͬf7z hGKҚL@!#,ZE   .21>#52$ /N&;G&Lh5WnX3_A'SB5cFYL@FewJgyMkzWck[`gnppyuoqpqDaTmey %"))3?%&1"& $$:4L\W[FDHR\XW[{bfnnFOJTrv[[nebuvyx{rzvwZ=kd{ezfenͧwғݎ¸õȼȽ̏эߜΗ؁ǩ͸ĭկӱݼģʧή̧ШۻH *\ȰÇ#6DHċ3jTX1Ə /f͆; ɲBZ@A8Y&JB$ i1ьVъ @*Z*RB#׆h!x_B UہhMKZfZoߩa@F2U``ZgC91ĢAf>h"E5m Pݲ}t8ƏL% Cسkν‹ӏ_|'лCbx!0dwypBu6 quBwQtPJ աpBp-\-_M݉ŌbH1(ՁAK+D-@-`".jw(ex!9 JQ] *q$-Lt,Ne}MY%-W ,/u{ȘTWaOFevnfgD-\W'cr|bwb+vtje Pea" -N(Xlrw"E,MT'FS]ВIQk^/" 3dK$c |AKZ* ̲,2<{){Jp -ڧuR(j } FfCݡz-dЪw0C [敆B'xBK0{+J1W0 XHx .\Ƹ"f8[1Bتlp? WhaI/hoMizg-vfƣB :l೧(SZmA2;AhO;::p7 l)P#(@<}u"PH1 "D0hq  !ݛʐ;"/ @!G䕷N1 ;bHkl7+/,@y ]Oj0JP ɒz!wC!wwK32t '()Rp!N,,+"323IJ{}B[\Vhi  %$)+1;&+1>"),':12'3;=LCISY_@AJJLAISSYZPYRPY]efbikdchqtwzzr}yDFLIUR\ZjwWTZdfmlblrv|vvz{wx799ƽƾƺȻɽ̿΀ҏӈߐŖƓ̞˗Ӗٜԝڇƣέ¤˭ĩˤҠݥݫԩڪ޳ijѶؽվӤH`A*4ȰÇ#JHŋ3jȱA =Iɓ(SR˗0cʜ͂68dϟ@ mh}vD8ӧP=7(KjʵԣVJٙSNp)ӳpZ,˗hڻmLX_ +̸aguL2P6&lgi6#%װ+ZظsJ=u ~4OμЉ?NO_ΝËOӫ_Ͼ˟O??Ͽ(g 6C 0#@HʄL8b{b,h%# 9?%AG8&0HzwKiN>'gA@?BeYxQNl$OD7lj?08`wgYgޛ2G&05Tx3Jxvxl,O:WG)(f^*!{S- E^TTxxKx3Cw B|LB*x{vx6$_"A Bwเ4O 8AT۪㱛6Lk +ocM8!??Y?O`[0ͅBl0 L??|?|o h" O8`ޗY]#xGy u.MϾ7{-^҆# |#Lrrw_s*+~*?So=3SNyeGBhHS a| % u!|GL(4zڟ`H>w( @t #"1=><$2EHA69`E,zу[" ah\PEP4q41@kb6gu G.?͓#Hr* U"CŠp$Y=1%-E5QX wGO&7IGPbdFGE>[[t}nZ7>EkG&O}2,)ϓ|QCK[RNK` x0YPTqec S`B*UyA&lY3G]S*< e.SR< ins6ٻ< A L&6n&ě 9ɫd;)z!D4+k9ne @НH1)$fS]&;]܈^= ? QH<h[s]T H )TG/~ `h̅g8 G6diA Grqݫ5=}<25^Յױ֠=%#JT T7CS VXu ؀Xu2)+2h1SP3jdxI&#X:3OS>vn`6]u_UzbXeuVEkVW?%3/Y`Wa1e]R(5TVSH8W `1F P\~d '^h\:KW/ fliK~[wƃfEYqYȄphW VyrZ 8y779H ר.c>Ѡf0 Wgkٖ,X>>aaAiol1iV(c4fcVe;cc dB9dfdIKfMd!eCe7ve:FU eAdII64n @+P% a=w$ C Ù)%-BiC2bFfgfmprFgvgg|gth hv 66hB* kfg!֜vh&iV vY&ij2! jvsk* :$Jo&zɖ*Jl,ڢlBma02fnn߶#9;喏n9Zq{9JĢVIKSGJIwq'*rKRr'r+r s?t9spt<*>7ApDgtH7pQSGSuהMuvhOtMw,0Td+}wLjgxxx7'hgyYeEz5Ee PP|{ķ//8U{|'}C0"}}޷7}*g~T7zm{7o;ǀX9G%g,4h@ ゠5?`69PJ@8Q֨XX5p5p3^h54wxoqȊRU8ڊ,ɰ1ExIh%8898Ch8k|[Z%[>x(<k؎c?k၌L{i#:Yc}]Pk T;i^ٳȱQ%y^^QJ,ȶ5_2;9b=?`մ^Xb߱>Y_Dvٗqhr9uxTr]fi35Ve8 ǘ &*Aњ @88T9ٽ2 )ʫaTk3fn&ATq乞)B jg-":*,B<6 " ,X\-ulL,H 4:4@ GWk5qvm,B.L~]3LUjIq 0q8u'J\KI8Gqcrepg"LPEu&UZۤyrvש,Βw8wig0űuWzcXլϺg{aZNZKk2,ɆU2K9"K:5KGh@1HsșŻȌ7 W,x7D䱋X7\6,Ѷ)u]sS8\u%9|ּlX e8 `>`+Lbc]Z1I <+diY䛻ҋ =nrf۾hF+쩿]5,h(W8F3:L̡BE=]`DHDGQNU@=ңH:եVՃ2 2IVXj[*pBt:t 9SKQpVzpD WKBqm7u͡C 1|ŇuʨdƐx7zWvm|bgvk,Sjmyzӭ*[u=gz z/«ENE{QR܈Y~ߧ73ȿ=r$15ۓzTm OTeU]܃ +A̿} Z8\;EX^]HW(z Xw8 O|X-ݱU˦{ZPWJY.!WBߎmÅU1{&0/\[|=瘌U[Inp|SLh;KdяH^_ (ٸ^rːQ_a*:Ζ` faɁ9\oEyaaLO"Fb{bYi,hZTk  c@d }ѻd3mJfeiT֋) Q'ދ}Kkֹp a u{NN㩞, Rӌ!Ny0i⑻9H i ̶EjF |kPmd 3-_TP R8Z!G?n@'!GՏ5o&̤%-"^#T>LqrF ^TvxMt-w-y-rfZ7#w&r*r.goZFsQon PtGwĊ-ZNu_lbۚ9]Zƕjڀ/Vއ?ڹpiQpG-۝Zy_ێ'ẜwPz,zȽ|| ]|o)Ⱦ|~֝ υǼ~wݭo̮A^_MU hA4Y.ɂ _h{ P쒘՟VB/BQ իk)+JX|88@qumۮ.;ݰz X0aS+Т{1@H,ӵpc2MG$ʒe X.mk.9#řDڭx„v}c/`~ ΍˽{"aǮe_{Xh>zmOѢ P>,Ҋ\@7CO=$ [I |."89*:腹K ;;ҢϾxk!n 鑥 :#YJr&4)J) x!#܎% 7paTNFFG9|ƥdq*H\X&G,?UH'N L&;v1 -N%TQIԅPUuUx~SSҤ4)6uQZVf4ȂI:] A 5)T'jKԕIcnږ8Mz7~*}^ÌY9'C\͎`V'qbĵQ`՚͔NQe0>8tjY;$m}S<7Vƥ)¢At\(yvG pmWzk{눅d8naTچm[+޻ |G#$<"ь׻S۱փ>}!;&մvq飺jC t@"2[h$g &P>B `y` (W"y"{C :CU7|_5&~jゎ إX.nd`H4~ TJ,$A fP 7AP MxBuj(da ]h@L3 GCP;am(QC$b "&QKd~&FQS$CE,fQ(TWe g!s GP0q-^o0eQ]8cCJH& G ?; )$i@6 R[\dMđ3d(I) yBKB8VJU"Uu İvBp Q%.OH0F 4[#[@1[y0hG: uXIxK` Kd LgVs<)_J-z.{ML i;p9 Oǩenz) zÈ?1z0c.\'͠Rb.ds=Oϩ`. AT@Sd.HA)B\q0gQki?.զ3yc0G}UKS)i&U. 5KMSj(q^Zd'`_G֌C!?4) f:IdjW&;͇&.UYpZצDlRdKۯHkf&̚jn \< #] ĦP:t&)pvȭ7B:c̬gڭtAZh>/H_Q* ݅OlEprXkB.V\ς 0T`޵@bxcIԢL01v|lƌʑy Ê0}ck-[ 12cd% )$⎺\ZW"!qZ֏%miEU."I>na3d.I5ThHSUԬAcه+ZXp{\A'-?{sm]S)L_੝nYNnYu.=Lo(Hf;S\@;Ru%A- uf~NB*3 jHvY†e#WH=:-iK,))"iFb0x i{r*+ PSISZ HD`:S&t.:u?\o싴1??r 9@x^ћ9[Kbʩ*:*)R +EZ 9<:* PX|  AtTZM(H*A !IJ3-2¢-≵B` 6,Ҏܣ7З,3 Yn|D/31 43(1 Y0od#Hc̻ 0I609+dfGj2Ԗk^T,Z[FĸIГx.^њ`ơ3613;3l|tE3#P9Hy 7F;b*{Xi C|zaKN'3Œ9YH[\N4Z`㖇fSVWy hL+RC̅ 9$NLȄBMM)c Mjyos6jcƅq#7%P p0Naa j`7윖N!ʾ#:7E8C$̛?:ǣ:S 9(3 mъHOP9C¹x9 =Pp}hJ(υ%F -S"QMQ)PmQbQQ,CQ)I#:-b#7! ,bAUaQZۢJM;R(R")=Z!-J+X%Z%[s~N(iFR}2?BOB*EXM%T ($$ћZYUӾ lc: $A D *2BA*+*+ ( ȃVf,V'v-Er"T+@_x/?M2ԋ5k3Z:+3xJ݅4E3F{[%3@]]3߽3H˶dޡ)^liPR]T5ML L\4eUcda۵^sQ51;-4Gә NW[xՁ_NNm[yN%7m= ]ȶΪd [3RO<{4&a2! 8<#P!bYxh չP E!Rb+I|b/9./cr`2>cb4bQ ]2㯓SR:> )*5:.c$MyZ5u<7M9ż:dxBOP曽7N#QUKL8]3.U !UVu^Ve>!hUxԇ_b>fDV;?fͿa(V*Al)mנ Xצz X- BBrIXh׏A%UC?C]Cg I\>`M\;Q:g4gڍ/FFܴ(ݩhZINɑܒ$k/N^2^-l4^D?ޮ<^q,T4BP3Lʹ]Nռ~ЌəٝqbLcބ`<` Y^^\9ƞxCdPb7.)Rba *b3gSb mQ5 *b6OFd5oovQpp767κ89>5cQ#">6 & 2d,-` 7;;</4ʩHWj0HPpo'Ơo26 My 2zKtyo!H! ,"+   +5, "/:323999 +Q$2S1M\&JhO8[1!gJ(iL+xN7BBBUQLTVVfff2X  %#+8&+0>!), #$)+-:12<=BLCKU@IKKAHSSYZPU\RY{wefikbcquwzz}zDFLIUQ[]kUZZebltvvzzwwzxZwTƽƾƺȻɽ̿·ҔŗӜԛ؉Ȥˤӡݥݬөڪ޳ĹեH`A*4ȰÇ#JHŋ3j:Iɓ(SP˗0cʜ_- LHϟ@I1 ; ]ʴӌD'EիXF85iȬ`ÊUBp;u۷p/5aTw˷3HUl]8+`^ 4Ƙ3} ?|*'֫阜Gq^c6_ =o=4A^";įʛk3pɟӫ'HѯO__j6`.ς 6F(Vhfv X$h(b!+(4֘"2$ piH&L2ɣO0'̕ɠa8#ㅃD 6MJ9fw3Ή/?lc~In>XiLZa x4x"/h!bֈ覉f*)$;bj0$ "HBA?z|Aʰ +(7,C(S 6i뱻.hb S Ȝ3?yȪe>൹&;j:H^h@s$& *t?? }~4Ox t?+(#2 3 `¡(䰅6Hk 1M!h Kt'#pnӏ@ TL +T|?|VR4! n v_-$s3U!7( f]_Ms 0 6~Ӥ-(G3?xPd\c?.f`&8b93Y" I2/? z5/H; {)}dȰv N]dX˰sEgj Ȭ~y[^f?NT ]$pALG"8l@TIF Ս] hIvV ˞BM({`( $*ъz"_̗$~y 'AİH@@jxC b"t!Aq<6͋bG꽉BX$bak@q 0 4JQ@7@ BY2"jScPpN۸H*"tKY.h(1QK0nI{%h}B7)ٸ#ա?Z;?9}Cx?&OiNtLdQثĞ?1QDag @P}3]"pp c Y Qv2eK OA!ؕԦ2 \eNwSHqD1!23ׅ:PmcB&$jU0jRA&Q  ?6镯P,,A;eIK6,H,9!:AMuu b?LQ"Q;#gmÐ  l%θF hV:>aCU/{[\8*H;6ZU`['0-'HB°aW8ZGbԏ3xC#D"Tg-qOg Iz1H0:rusRuuLM6Zӫd5ZU%,^S| v#p.y]Zп:(f ZCn@AE1$h 24M!.tI|(XB/|NƠi d PraņȘ5D8G:qf㙰@9B<!K}gOHv6 &G&BE.5MrI[Z>׶-hahbR zm"m R?6 jfvL:Z>gqy-sp\?,B0!Iۘ<rc254<{s1K,䭭H^6*^/F^'Ӭ5z_y0IGͧEqљU={&\!/`YN _SҎEщ_L|PIwF$W}wz9 #5~Gdkz #`w0P "Q8Z{$DKe4UrCM·bKou$4.Mr „g!V!qMRRE>FrP@u M@y1 x :PnTHGs x S-P1)wVrV1@=0L  rc$VR1EFFpSSSb(TrRt5!fe[P*j) ns wʂ1B W c&hxV% a Bs v\بa0$W$;UXkZ!c$(X XYOR9S I bwCAp rY!N Z& "[[UT[X!#m~*!ȥ\̥$%]]XiR T G"Ji_^U^h$^$pE B gZB !c_Y9f)d9"֘b a;#$xaRA)Ir`kOFF,b's%8&)$ 8g$A6b"4dF2XayGy>f-b+B+G2-h++l6,y,"!L--".b.(g2P >R$֙fCGB!˲ b$>P rhـ@VќEj j0W$f0 kAIB2&#0*2L3B1ڶ mEp3&3\V )  zp4L36ğ&WpD*uw7{772 B4y !E r7Vbf3qi0 sq@`$9P}LuɆ-T$Iw@Kwv t$c&8A 9Ֆd$7z{J0:qMќ7wF8!LtR 8 htI!Z$|}wuP-N0I2(JjozSQt؃3HFb%k' L lYErH[$VXRׄ שXWF  j'SPΤOkEDQDQUz'H e=FH!P@?5Рq =l%U2>:ŋ8T(!TW`$VER "/$KUF" WT #gz(my$$uux(ɂ qQsE)!( cK"|XYBA"3krվ6ÓǸ)\:Y%J$,Opwm034rc4?ff$IoK*pM5 å8@qiBvt='r_)!\$w ~s2fSoZrsvɨq9xr;\Wԣ|O9sZ$pIbe`$dG!dJ2A+4Ϫ;f ȩsCgGpyګFrL{ zEEb2Q0A2++ZsjBC,\&#аv1:'Qr 2+mE" hzC-̎$^ׅW f$ݳcnG8tG>XY{#&LkKٔ&g{$j{0c6RH!kf`{bK߈F/z{ZsNqHO(p!#&۹؊ܚ˹κ;"7Р-R[ۮ` :K+US=ЌT k R&!|қVT1P$>n= J8X&8 Y;aIВ$M1Z7Jr9) "(=)q\\P*U6na8$p $P‘mQ^2'aZ!XNM[%aěb"d.o=F)#(cm fNQ"m#lƱi~ey*f'(BFR+nf${"p$ Ƞp. v"j.<ʘFR t SN3Mգ bˋmoB1\ņ38M Z6)l8R6MB 2V *s!s r<\:9Y'͠ [2vw A<ќԵzJGz&}<>M- ڧ2MG= |C?CA` r d[-^F ŷͼ>O]drF|}lrت "U~P4K٨8ם-&F z R% Y oLe/twuct0$=Qnݐh. !CUk$ë~ KTFe-[ט a|?妥{ޏKUÂi$0 B)+x,?+ο-e0.\;[R.,!M\<\%/|Y^l^/O$XP? .dC%NXE5ѣA!E$YI)UdK1eΤYM9uOA%ZQI.eSQNZUYnWaŎ%[Yiծe[qΥ[]y_&\aĉ/fcȑ%O\e̙5ogСE&]iԩUfkرeϦ]mܹuo'^qɕ/gsѥO^uٵowŏ'_yկg{ϧ_}p@ 4@TpAtA#pB +B 3pC;CCqDK4DSTqE[tEcqFkFsqG{G rH"4H0 'o! I!, %?/ 4,323M#J 1O"2T-PkaS>@`ueot  %#+8&+0> ), #$)+-4;8;>12;=BLCKU@IKKAHSSYZPU\RYefikbczquwyz}yDFLIUQ[]kUZZeblsvvzzwwz䜇wk׊ƽƾƺȻɽ̿·ҔŗӜԛ؉Ȥˤӡݥݬөڪ޳ijѶؼԾӦʧү۾Hp *\ȰÇ#JHŋ3VDqƏ CIdȎ M\ɲK 8sܩ>{jȳѣH @PIJ)իX:,GWA{J,kӬ۷E `ZmRAV ,/ౄ+h-Ő#7l˒)9fĝC;qGѨ:'4԰`>>S<`;&Gw.K}կk)ËOӫ_Ͼ ˟ ߀hHCQL7 GF>GB1 3*(ꩲ>+h,'pOZ$"#&Ƈbz4?Xy̑e~AzKNiaSF飖9$y>DR.(l&'gzI ԡh).|Wf N0P7'xv7(+ Ęt9wz'y2 ޤvdcwGG,rA|7IGCH= 7=zr"EcP<t x{б]Fϴ:%Wȶ\p]/>.cP0-lۯ /a(̰r̋Q p|w#wo1Jo?ېycw\JXO9>T(VH"=xW>'5YL-.[@Uc5Jewwv_MF3T8xOwwBȶ=2dX7Knӡwq÷xӓ 8]x:Oݕ~zw"苓Bհ8߱wKe7-ܰ=((5ld0is,Ci:C04gFCnP~(NhDgg"C}amhZDZaEmD> K-=>VpmnBqIGEs{L)QڇP ;x>!8YH>ԲJUY=wX=Q P:47`b,*IG\kjY]ה9™ m5ZTIpvݺ wgaVN҆0q0xJ4xj>Y㵐@^6yFC 8vp}WWran=O7PE xGWu( l;#`TNy %?bқn ֵ˪/){ꎵ0#t'ݹ>}d}뤀ί̰z@$sEwW 5h/"<{kx#=<з#*g~FLslrc‡X#FPqw"(6< xhƖO;9xfO_M'_tB:?ףjrD3`wLw>]w5vpD6bx6A}zG@xNBF*h5fƣ/tx'' [[:87GygwXzS {;G{SrB*JDʦI>W|׉%j{?TS \gI~TIytK"GKi ?kOtJݱ4FI ȫ$+7Kt{p0l [Ռ6Nx.N$4TMăK5jzBOP҄D%1\h^DPTRc&P p$5Q3E)RARK;QJp S=S(U=ꑊA)9wk8)[ũAbVIkuqp%WteWX8X`hGIX#H\1J] kb[嘳hj[_Z!!i y[+ ɧekvKXQW#ٷmYk˵w+):uRjVTvourX"ZR:T \W;^ DzgLr:yi|+ z;L[w쐒BChƄ*iȤJ7{Q{nd,g|x2Q=GHĪ:g1׬g:z"H%j˶ %ʬGʃla,pK:M݊CXqw`uጰQ9\7ZY&롱Qy65#{]Ǹ䑲4UT1YճhiΜӸ(XXCl.24]f{8-:]p[AU8+ZyŷA8ő5&h5-ո$Mn2Q7i`bI_k_K Gab6?}k-e֛998akieZg%+0>!+, #$)+.4<8<>12;BLCKS@KLGKPTYZPU\RYdfikacvzz}zDFLIURwkUZdlbmrxvvzzwwz䣄`ΊƽǿƺȼʽΐŖƗӞӛ̭ؒĤӡܬԩڪ޲ijѻӾӢЩֵH *\ȰÇ#JHŋ3.DƏ CIĎ M\ɲˌ(IM1 ɳϜ} J$ТH*< @uLѥXsf Yc >7Qdʝ1-(Y\?L9|̸´ +s!K2Z5_\y1eElk\#[G 6f_^{o |qŏ+g|sKg سkνËOӫh˟]Ͽyn"v2p ׅ94ރJ]'&P蜓4bۙ"aq!vgX#}Qv=u27x6d3H#w<"K*t0"&#}`w#[:ˆ abM%,\eP \+L|#*`bM!21&ݙzbPH6Xݙx Ad稘bǧZ&ri 9M%:xёQ"4eutBHPyX7Awx': -A-k7K>LsA+M 㖋ݴ^N*ˬ1S/۠V.]:ˉLPAi! :b++@+K,!ݶlqKMpLlu)߱-rA^r| ;/:N ]/nj% Ab +0!}5y] N։2:0R@6"8X:̌){ :?[w^+Iusx)7]M^9^ቋw v5Oe< hՑ 96NNTXاgmߚS~jN8OƒCNJ?,v__{ 0A RBufRYg3d\c!G@VTuʀV(X :t_v@P;%A&kʫХ`u8,w[ XX$8c1:&&ȑpCXu1lGwBqhNV : ӰtaTa$Y z$d6`0FA@C//td!_xD*:97R$:4yA) /GxbeHUGnh9qy&9bBWcO;aW F8BO 03D Šu&5aSb9iޤcrAI @x6iC7p|i" %tN! Qb!{BT&\0}N>hI%zRv4;G= N bQ ,N-Dڸ|`F@j'Pp.Dc\gPP7VB@@t%f$O[q WUAVȕ\=c@&@F&:Q 1y.Y_qJ$r/ۣ r"a`yX-]UpmaRmEkCA| ?UC8s ]শõv]R ;z^!{}U(ycTNB,,T=iovf#w\@-+aP:9p I$gr!҈Xܹ1`,XR]D&3iRkjӛ4:YGRSU ɢ;4B*Qjԣ X9;d.?`hI5Oy+s08gqW~mLqGN}'ҼT:(9r^Hq~qI 3}ck^pø6y$+Lvǔed%Iw{p;x WZRYrGԴ)Qx6SD:=vy2_/jxEg ;#~fsO4g~;;hEM iIщFO5HT] ZFCi))Xr?cN)0Ց~U0W}]ޱWQVgVWpXu911%UXwyla}h5YiU~]H3OwVbZPU[c[B_D+ƅ\ӥ ]Nh![؅fx^d(gᕆpr8tXvxxz|؇~8Xx؈q8Xx؉8Xx؊8Xx؋8XxȘʸ،8Xx!),E  %323@&K2*gH(FdwHgxKhyzgLqvvE[l}   %$*1>%+0>!+, #$)+.4<8<>12;BLCKS@KLGKPTYZPU\RYxefikacvzz}zDFLIURkUZdlbmrxvvzzwwz̧xƽǿƺȼʽΐŖƗӞӛ̭ؒĤӡݬԩڪ޲ijѻӾӥѨHЛ *\ȰÇ#JHŋ+"-Ǐ CI2"DŽ%S\ɲ<CmX!c wV*?w\{Օ&PA\t 2^IH!H! qfX!xAxsq)xps"Ψczpy"r;($0$#}g#G:H aL%+ Wd\ 8 *K,#)XL $ƍ9f^PHQK4ܔdb@|l %^) L%9(Wƽ="cppdBD)H4hAv(7D+,RM5T =,A˄ FKܯMڊ0pl.xBވꪉH@( V:7b**믒 K+ ܱlKLLCLp,pq-bJ"܍ w7.# L\wLOވ" *K u 8\ 9ܰ7R<`557|M(g{м7+ vJ*Ipr(5ou;\vޤ43N8w (ࢮ3Lk7MsNEӓwlژt~>? 6KB_ѳ:*qǻK+/ ЋA Q- D*\&cp3 gC_pG 0f !O8{_C@')O8T`g\ IjP7~T=AGBP82L#O,l?B'q oH]=_pn qáhit#w" BzÐ#l(0_hp@idr8,F[rd]pfFpJ[(uVjÕހT Aas,&1y`#Vp6$-m _Pz1%Fsj1L06oژ` o@S#qZp>oX s+ָQ HB,rD(07 Xz6э:HL1xFԟHsP* = ! }E¡y+uf ӧq &8: p$$,s9Lu'@ CNN"Ed\UU@WEW|\؎H!azq :IgUb!2;- LJ~QVmPi)+ .D;op6A t' P3q VemeSZuBHqtXu!u]`nwK^7JUN|jDYӝ⾬Ԏ{]Gka_1"GC7׺%S"X0Rx` =8M΄-s~p$1IPt,mK_ p3iMGeh8AoӜt<)7bK8Sb2ZAVU:{eP` X)3B8+Ye7-Vh6 ]o^pl`x9i˂#096ؼ1NQ9WA-jd&CІ0N'ɩpHmjy^38^k_ 4g6j覜){VŶݱ)&[IhCSE{ͶJGؗ=mUz_D4o}o8Dνo l{"{8 l  ,!nu@a'%T8g&@[Nr 68Ct\!H?"r80\s_É7>q6N#Gniu1,dr$iP<ݏTz"u3Gؤ =h/.r| La}f.K_SA\g2;mreoܥ7\8HHg19jفs=t І'EGSThRޘR.ԧ5X^7zO?_rΊNwV0Wa84#kWceeHk!|'}Wh}ڇ\ENuvaǑYeOZEbrZ.x^0*E[ [:( GہѵR8]P8Sxa!$,.    % 7""- % -8%"%3&))69!78)4'$3+$1&&'( -7>*!<2#K&E +Q5L=X?]?f /R(4G+1L-9D(4V9=B.:cC,L7S;HGHVXKWWIbUiY{BadNjSvZeliztg>GL1M\&Ih/It?Zl9YqD L%D%J3T<F4&[4&Y:1m:0LD8\I0bBhK*xN7{Y6QMFZSIWYYIXdM_zQNaU_lFdwHfxKhy}^M~[PzgL{jLdddqonrtu\lmu|2XE[ItWeVqbxl}k{}lx|nwy}{{wzЃ\:g;nRvWxZwTwuov`iƓţwЧxȗޠȜޢϬ̯ЩѨִƴظɺ˨̴үִH*\ȰÇHbċ3jȱDžCHɓ(Mˆv {0̖+)ShN Ϡ8sɴ7UhgӨIs6}U*]XϚj5U Hk%9J@ܹCV'l"8+ ^|Nh)jMx6ڶ3(A |wn݁4Ls c5(U&y꩛i!~&6Xr F7}bxU?8I_ވpDt]vur='>C<R?@5SB\i.pq@6%A=d @?b?.{sņ(ť@),BΣ@pĞcyȕiAD`kBɜt$lME,L@O9; T@O,Гi2 ZA@6/4t,.3P-谢sj\L#-rб@-=Ѥ~5/,*j,1$.CBvF_3ވJ? tO_wC5v7H@eJ%@(z,gul?@/M!'osC8|+~{Lf~@+#Ї $=\=ц- {6 PztLE| \p 0kȠA7s! EA rP X jr'"20|yA@hs@€o%hD$&?L .DL|Hn, ds aExAA #klc4b~\HIJC Md= D2"|$BP[@E BIKbR$BIR$L*A2UD,gIZ̥.w^ fFIbL2q9e:Ќ4u^&!6ЃiJ @7w NqӖMY83s%=)OZsl,@~:f"yKte@Jh.eDki`',@RSh~X&A}Z*ˎ~<@Bh)@0C 5I() 8R4I)PT*⢴L*I:Kԧ|"b:SY<ZˍΒ4S@P`TD(H !W-}U,]y^@Hk79Ym6k`[XXB:2#Չ͌M2 9\  @C`ge抴D* Pׯ}llJ_R$o٫n7O5\\vtn,f+ gd,)\:w7&&h`f8UZK*>qE|lfmP X%!,xM!]*7y8F0!'\z4Yh,u|ՐEpj}'|Q]ݎct,.!xsŴli x^| /^VhJ4W/ 8΃|/\_eT2;%\Gx} ؀(~8!,+323IJ{}B[\Vhi " ++6:$;2",-"&!,322;9<5:ELGISYBFFFHCHJRTX\ZQ^]TYX\afiflncjjvyFFLJRSfehwþW[gkcefluqzxryzwy₺ĵöƻŸʽʼʾ̍ʎԐŗƞřΒҝЕڛۜ܇ũ˥ӪҺ¶ϻչӠH*\ȰÇ Hbċ3jȱǏ+|ɓ(S8ʗ0Ac/™5mlIQϟ ˹QB9ӧ*MQLIBUԮ}*Wo5ښoӾ=v`ۂkΥ{7ر?Vp_yTx٨{϶&dX3_%fXxed4f9l.tdtֹќv'CxA *蠄j衈&袌6裐*Vgf馜vh pj꩝jP(lj6I(т겨J騊0v HWj- 16JЊH;nE2N mnL Q{o*o7r,k pkꢳL;+*2Ʌˋ._,3{(C;Yz;s)r.I/=ӏּqd3 &(Q(^}4kL4ȭPi6;9(;P}7HɁ27M;-Rש⼳;W@ |P(^4D>VN:-#M(Oh| h 'B>q*z;;(;:~ ʾcϦҴ+Yb3&4% t(hwBsG  ol3hpPV@2%*Š⵻#Nh1BsRG3v،^Š0r B$;8BmjB{7w@|EHq0M|Z )A]@G9&h(<ꑏiBrH2"H-{ II':+n)"MzR](GOrSLJyVBJb\+AWB-}KWd堤j q'dNDJa *^Gȁ+EMpCҜ&5u &% {z\, 3upT'|wt'@9BWLŠDPvέnwc2P0\+mF:VtPRA vGSRt] ;j S0wHF5=9|/|S?pwm)RU J?W$D+z;D% $- @ w(V{=j_B^3A;> ٧5{XyۉȶMqΏ#+Qᚐ4.Ntn"K:,j{JvQTBew(b3-TU^T>¦6_B oΏ/+&;_/T΢v;,vۇ E{į\6׹.-q3ch{l!ET[E//OZGD2Ё~5X,f,˥l W8S<$F ̏*XZ* vI]Qzˡ.ʣiLҍWlZZk뎚ԡ%iU%o\Z+W\+"Q^AX y +[wf~J{5ʙ")DUv4+R@wPI/iBm"B^W_y1Ys$PyBXݘ}VS |u n0T@iAe^i OQ'/EW?JvBOT̯B ]0.K;|n@ٰհђ V7zPpF]:(*z(_jg8eਲ਼] 8)䀌w%\qΝ)ɇɖ=vhQ`N/AXp#i/D)5P?:1o埀~]xCL  1:,]y1]jGo9Qo|&PW rv_P0[~C脊yUAF}/}};7{`@^&X`f7eg݇&T szǀ@~9gaDwF{(fBgqC (zvM0Qot#=lGNNF1:\KPTOw/(N5# HWz2 ʸZa3ݐ9SdPecv*qbtby3ՀBSuf)!c:Uc8 9XWXg| P6` PUuU(UJfP?㰐BghV"3H[lg)i_&#L&XX*f(;1a0ZAZ7Ʉ[F(_7#e&(@8ijJ+iiW)oYi[UIw_`aycIF)jgY*kmxoyfeY{sa]jl `6D0ؖ'!Up_`KOpД(@ (3wq2s lW6kЙTw39ayA#i(ia( Jy)mrx8SvwIo7c;؝3w膷Q Wiw~I⃑)Y)(e3%9Y(C3w(Wș^ԓ?ɠg)>#E~LOYjw)Y59J=e?AjuE)7 IGz}Mj;*QJO*{Y(G0,r,k".`_^411_zvP1g̸@4=zj(j6w(x 83y:OccKT=Sڋ2W(sC2Ǡ[q@]ց`At_ qBkƃDCTDpjPgbTddGrGXVyf&HjȮ⥂+B}& !B"(z:FtlZ1b//'t2&32ᶰ Ƨ24ĪI5[ai6|6+˰ y()(8`Hj9i(WcSY:5;DJA9=*=r? [(d:Uz( n?I9(ATAW œDŠ{#cC3$fˡQѬ2YT5p"J(tG9K a¹Ṇ"Bakn˺麁j|s (fklF9FA P0()ɴLnVLR[_+i*+(M8~ r0spi oop.?Nu0*1za%B8sYWԸ߇e(˹@+X ˟יw7yޫKF` TM[W g|̲,9HF3M(iF@k: SuWY:d/ VAX d[\(Be]YC(g : 8}K;EJAj}:߈n>s,_(+Fҥk϶h!{VB&•/0X 0m1lq('Tj%B5Tۤ>팋(s8<ԔGfʤc:cD(;޲hש3L~Br`E6Z&^(d[(L\b&n]NCQ O8`@,:Rf` ^#@!,)+3239991OBaQF0BBBVVVFexHfx~aOyhJbbbjjj %#*+?$&2"&- $*3;04;CLJWYBFEMHEHJSRX[XQ_W[ccifnhcjjtyFFJSSfeowþ[V[mcfhvtvyx{qzvwy{e¸´ǻĵŸȼȽ̍ˇЎҌڍߐ×ƝΝЕݝ܇ǩɥիӹ»սޣH*\P #6Hŋ3j<# CIG%S/ۿ ya$'^Lhڵsn8iFB nI.eZké^/.gسS [0-յne `ۄc:\z+Р>7h[NgPw-{oUu;~ v1U/1'&lZZ YnimK}:41[Dꝺq+y*A3G5B.[8֓'|mХOǫ=UW)ZZٶxs|dq]߁՟]{0ot *}zxxi5pae14/b$^48c8wc/Tn1C߻ԗlғ ҷ^TΕ {'$(]2ڕ 8=^#I0a;`4$..ưLPF I.$ U&bXD@A` 7B>fկ; ƪV*{ܨF,21Ά3 mhEүޑhꚣbiy6;V0t Uqn"0I8iӤ@JO c%PJSJ\S`5Y.t&74 O@AO4`M]dK1iws GFF ;|74U@-ܐ ש慩-bZvK `kQNYcP;"8~S 'CsObF3->Cϩ!YU.!mC&,o) 6 Z= `'QlNXԄ pI QKSg<?LD<vZ/Ԏc'<\p ֙u__,M6\Y%^6fwZp֣mg?f۲y/K[0J&|aB yȣ ^j4ANBM(6d.u[sr#o=kTgP*Vr..^,P'E`aѾ.5j*`u000|'pT%@G<;jhUd//( ,^ԑn\1!XV˨~k\ hZk 7IZ7pmo Ye/u[iڜ\rL+mO;N )kÙǸ&dh h"BdS`1ryѠ T0L`LlnS箶uA1j;f(AxҔ٘\ȍ#dr?=O@!>N}Hh n.d6zrl֋TLhBsk*iK$9vZG9jU8}*02䴴uAٞ B@mwn,~0 N@u`=q3WseOstS1tX8 [XEwt_zQ7S spTBm}'SulH53 g)G8vx7T>q c CBGHw4 Nl>G?swg Ň 0dHEևX=GspB0dws~~]y=Fw]HHzt%(*,ْ.0294Y6y8ݙ:<ٓ>@B9DYFyHJLٔNPR9TYVyXZ\ٕ^`b9dYfyhjlٖnpr9tYvyxz|ٗ~9Yy٘9Yyٙ9Yyٚ99= thI@ P"q0K!,yZ  %323@&K2*gH(FdwHgxKhyzgLqvvE[l}  %#*)?$&2"-+2;0LCFEHJVXxeinhjFJewþ[Vcfwuvx{̧x¸ĵŸ̊̎ԗƞϝЉǩɥ׫Ե»գѨH0 *\ȰÇ#6DH1ċ3jTX1Ə 168$`G!Sd 'W\9gyΟc gEH9X(ŤP QӁ=-F:0UnzU`V\ɂ=vW=FU 7ܤ^$QRٻH <7.`oM*HC)y2OÖ>̹ϠCM3ӨS?,ͺשcXm۲U;$] #Zb8ko?ȍSQpLaN"'~T.iqdHC]H@$ M|^h$BgC"xP`"d4{6Ux!gp"/pf`"rF"(&R0ٌ5H=TB!B7"|;2A]DYxiJStĐœ W&u8zgkna Yg+ `4(Ch&rG^::^8ږsx/ʁ9kS9Y-`"u>#{&yܲ]"FzֻɷiMDL;X'=: j>5ٞPud-؆50Kw`- ڲ`0Am @/3afV0 gH8̡w@ ZH"HL&:PH*ZX̢.z` H2hL6pH:x̣> !,PE%),7'(&')D L'[8+bB}\8M_zQNa~[P %")?&"-LFEHJnBLwewþ[wsvx{ţ`Ύ¸ԗƝДǩɥ׫ӻբЩֵ\\ 01S GN %[EQJC%W VD̯B?\.URת [X?_} @Ŋ.b$q#- q$IHR\ɲ˗0c\͛3s?< gL.KhuÇXz8Q.^YT3#+Gpr$KB5˱vUk+T*p5jP#2t5_.!RNB*\8Dzf`;$% CO^۵ftc)ܦSzy $ 2<[yo}+,$AEƒu%zV_l ؠJҥ"gۖ}]3D_fx!kS*/ɼ/bIrR3aNiF,޾wN G{/7悠HNسkNË.y7Qz%/Iu%evCu @] &XȂ lg D0@u("P@Œ!HB x݆fwI'a=aduJ~u)@ dp IݓՑPH0! tbG'uv^?`BE q.%jݢ~6PNHZb r H oNj))v~BDnZuNk . >t)+z8ؚ "" rmfjHҹZ$V'{yl]<޿'|p 7 G<G!<,)+"IJ{}_"B[\Vhi " ++6:$;2",-"&!,322;9<5:ELGISYBFFFHCHJRTX\ZQ^]TYX\afiflncjjvyFFLJRSfehwþW[gkcefluqzxryzwy9ĵöƻŸʽʼʾ̍ʎԐŗƞřΒҝЕڛۜ܇ũ˥ӪҺ¶ϻչӠH*\ȰÇ IHŋ3jȑ ŏ:II +ݿ|Yp͛5o9S@”a*_=vu77y{mKqw/䅬 n>@$v$kƞmg}^r'u)Vay}j` W"yކL/.H#WD$dH&БJ6dAL>)QfXf\v`)di&Plb tirp"0EY d`ĢP$H2 F:靘ޙ!HԇW:p͕"J ^!0ZO8QHp%@\+]\+:\HPCQHbkme-f ['1o릸[V<ģs oa Ѹ(5чb:OaI{(zSFjҘԤ'&a+A0H4Jd8NJ2N}*,RR*Vխ*^5"X*ı1K0ֵ5S`iN-œooXHq5K̫^:ry2ZB`HX| Pl99uU]d XV6r3>J֯elM [:mj٤u^oMggKb]n;KYޮI Hd+[h!Ā5l|15hLd7|]n/@>sU G:M_V[&7** dOxeCO3*@;@X"PGH}Xu?x%"!XT|ХQhG]Y?\8R!5˗%AP gH5%7F{>.+|ocTTHG'wu}&؈`%8\R%Xf'Y~G~-FYE@j}cW~~W`pIq(|aRg >p%0Z׀hX82PbȌ(=/Sx%# ~f=*Wr; %r8F5%?h,x%cQK>H CXQhxI(\Y؄z(G_b[}ax_rWBD=u%.Bxйo9dfzΙjlԩ`ڦ]XB-D~ `~bƊ'aE0[~;%8yT d=fGG)WH Y@I0tP2j g_aF cZ`XFrfe8Jtj+i\8L WrL*=m]8\FiZʺt׊Ń9ZiZlΚHȢJ/Hլ\U;@6X DQ:u*X-)]5:Z7hXRjuBZ>޵*^  4Svx%h0 P20 `xyA )rH {[xҖt&qB;_RLhǩ>9Lbr[9c(aEFF=3~ r%f{WW2~yNZdW2eA@(j&=`7;NH Uwgl,br#`8{f,6髋{eΦis7l7e>̀wZxĸ_hk6mlKË*j6߈pk_mʄvћ%n&omVd3 p;PprfoAo8N̫MK-k`Ak{A*57ȓ뼇r,-8:j0r0G(Y(L{tI绫K dZ˽2ܠL-K/:,fxJ÷;{)xwC<϶n%M:̽1y Ŝcy-?h7 b?dyl?:Ÿ{{ĕAz~ԯD. yS%ozL,aWfjbR{%r+tGw9: 縎WǸɘu[rJ8ƻ9%.H1Q9orǏZr{X|f"%wv+GD|%ΆtH|לιʆAQA;_|yy{rL /Xt);Hџh5VY}W_VcUX2bd j,fh&;%z%zIԘLa![˺2:4'MaD3WbX25P]ho*rq\B'%3&1m2[Zt Iב[%cŃУ%I]==ۣc jV0}?nxdNP4#fڥb%Z Mdmr D9p@KFt21]R ]!,)+   (#,7%#*999Q5L=\6f8f9zGLAiFvL|W}\vBBBVVVbbbjjjJHXZ\jgijjb`itz== ")&ȯʄЈ.:šͷ̲ӊ,' 8:6ݧ◻E qA=N6WÄ)߮ BGz6$!NP`f,Y"Pk%t1I/=r#ZTXѨt De2]u叫̣N[*U (ZN0eeͨkQDžeJt)C_ qmAWls*QL2ocʑ`{XE/F\h?- 0:Gxq]vm1nҟ.!ICW&4gگD tpD+_m|^zAb1Lӓ}󮞯 d `߁"h` 6hʂF(!&NhᅉTj ($h(,0(4h8<@)DiH&L6PF)TViXf\v`)dihlp)tix|矀*蠄j衈&袌6裐F*餔Vj饘f馜v駠*ꨤjꩨꪬ꫰*무j뭸뮼+k&6F+Vkfv+k覫+k,l' 7G,Wl'gwp;7&pC8!6,)55) /:"4:7. zW9EcIaVl_vvtvɞ}]pf|eӺƴœѬٶ` df(h{£<ӬNFCFNGbJDSF2bNQmJ(J5Z(9)SFr&}&# XT\^6!!;,V # 6%<%3%#* ">#*)7%&%1 :7!&*! *$:) 9%$$%!)6(19=+#61*666L.K7l$,K /R*8J%7W7=H+p> M@$Pd@ du@C0UP^ ixO8:'N|ߍ8aW .X>M":0:Ej8u  ]@ )WlI>f@> W-wL63:TTv\e%܊j|32)lof馜COiK (wfPmT*8f.kkC801I>XJC+ "C&+T^G@⣃@ O#m aqdF,EP@g1G5h >h&>씁ErS2ϔ:7h3D;`1sG](.._pPG.aG2[ u,(jc9}@:!6NhS\V+|@LXV,B"`1đ%~ߐG.Wngw砇.褗n騧ꬷ.nV38C`QBa!GXLlK?'wC YuPj]U[ @MX@p±HUnH(~qٗ G`+k # @B%BX(r 2eJ W ݻ;@!‡M! abC5C!H] F1A, qDxhE,m /7 3MFQ_/\H gxF`qFyS7ƸFIHXca@FC"l(ER4iR$ztb| G95Bt@>;UքGqCV,_$K4e=hO%OH71I I4MiR&6ݵԇ%hA>pyِ'=tI#-9!R Ҏ_"B>EsȵYːӀP5QT%=)5SJM;Q:g k,!E@ !)8i0:| @c*@ɲ(.IEehCC FEMD&3 d>/ypZbkXzV|hc0+Z*WK4kMɥSB:`2#ZV4D|HBUgE4?<:)4 # P!%iҢ4&uiH bBS :@am\> 9[TpMJU%J\oq)0㐓K.m.x_^|eL+ڷr.;B;iU)Κ; @YZWH"@f!Gh Bok_P`u:Wc{AQFH)OaNbƆDk@e 5F1kYa׼7c /3xlM{|pA9r2vQd| ɳV hh>YC wf4ix)ѩCmjπS6j|A w5:k{.ߦ|GJvAS@..BC"5gn& $MY@yjv`x~ol>y$XxE~$nq /5oSJ?AP 7aƧC#J*av sxyqwy811_#lQ^wX"f .ҏ BE\2n!+)[r&[('qߤleSKKY@F4},L2)M7"ionMDNqNח@!NO 2 2QO uT#a~MOā*"?.RkQZQ- R!R7hR9Z?RD"!S =uUS(9u$<5,B]@@TYHX"&c?LB%PIe6VAWmV suldWmxWzb~xM[QuYX>"u){'LYYZY"ZZe[ʼnR)UXWuMy'i``%"GY8{v]]e^E^%^_8+HhY'-҅`eBfKը_XybƦb A$&&,NRc/c<&T?6NB&"/W0rReb6x eYi( i(u2,(}gh4K4V3H`7!4V4GCjj7@YEjj#k?Q!c k7y&lflw#yS Ímfr6iV5uBGǠ) = * % s`u@^@@5 ] !'-p$GBJ"ѣ?57*Pj j/HnJ;mr* v zjj T!qꧫ~ 0hꦀ8 i ehju]= Bsj@ ڨЧz,0:!,ģϣq# 1 B >ZZ]j%a#1[Nn૵!\Z Q`H AHH/ʮ iZ9 Ṫ  f 캮* j * *_ @ 1% H/+1ᩦy`$%aa;JZj{h*A!Xaڤ QwJiZi Ljڲ z :ڱ,'vx++˸w1値[ p `< " Z;CQ2p`_ I ܃6@V;{+`@kx@[:H ɻ$ `JkYϻe=^"*(gNJ q ѧкGj7{5jZlMAc2Hܰ0 —! 05agŽ zs@[ W! ,!><Qz02,L@S5|0<( +0븐ylyis 0 $0d9J`p @л(k+0`7x0zL DYAW̤ '0*Ɉ\`3WRȖ<$G:S5UˢBLaji<{,Lux,9,*|cȸ!s+0B G̤cYj qȣ F s;&'ƙT|9˲/aдiQ˴Nlr<ρKzktu<!LF iLZɎ @p@ TF}@7qFBm ݼƉf-ִIf G(<ɺ ^ ,tKzLC MאmZZjפI}X3ͬ\ʴyGBsP$5[ ڭ/oˠx+ Aٜᇞ_PBώ 0-jSR0c e`\(X - m pcֽTiNB޴y/F*-095(p :K۝+^VHPyب\LތAԫ a1Z&>p$׫ q7pΩK#ev]0,} Bo7>K–> (n=c L>9 qP8(Kma`$=s8 BJk< >s|mӉѥe5]*NɈ<8Tː @GN?O% G:vc 1GZj/mMԏ1_K#lL^k."xKlǰpY^]*Ж 9't Bz ?u5O`B >2"CF0bƒ*ƒJybF!?6mܸÕ+$L>]+L:CLJ% @Dʖ-oHuPHi*[m͇$OJr#G 9r4D*@۷!!qH35y偆p?Ck2̝̽/+7axfdNTsc/F-[c<^)ԍ]~>ٱk|UcKʕ0yϕ" #!R! nB񥬎>*H Ц) o)An h?W:( "jrR ʇx2ɮ4;4"9P ;1:(dl4,΃\ /x(t"6 @yB :" (1k>M49B3R T: GT\;7iM<3ob%=;hHh'4h\)WC"*­S wCJ>Е W!wUD<*rWSqa܈7tCQм[1^Y^,|?eZr[n*g9.+ЪБE ޻P?甊gGiT{ !z@ }q9hڑc*y`ILeXNjƶvNmTڟQ۹/[V777͎zjfzٴгN2 );a~dh oXtIʿWٖV:^Yel;,iy\!nxbig߳>^Cן}]O"ahD K~UJ9кΙ:}+q"Z\ $p+S-Z!hiR~cKr=Tڴ (DJ$2kNj<A|!jK -Zet)Z^ ?r*2/DFjp\<̌H៌H9#Z}HljtQ .fH@[hB6pc˂SHTh %3`?GP2d(2GuLOle-iK{)*Jk#x>)F^PK 03dg3ϔiTeTd@7"H?T30 <)LuSLcbV0 8*0fGCPn* @eBP Laz 4o+]W5fBIЏRt(KF7~)le-{Wd) ֱW%XiY:emk-{øVgIkm{[)U(op%nqKӄxo:7)=nuW#@>,u]Zߝ554ސ^IHمJoR_n |`'X fp`GXp-|a gXp=aX#&qM|bX+fq]bX3qm|cX;q}c YC&r|d$'i}0H'?YQrdȃL.Ja,i.~fݼ3\@{R"賠\A:ЉCA#:ҋ4MK[Кֳ3mMӘ5I=jN+"[RWէvS kTִu+;?Dö5e]ld[ٟN6kgGu7 l/dn C>f-r1ӭw{Mnv7um~; 7p7|V;<9p< o8#~<gC/n3y?ns\9wo|9yo>=!/ӓ>oh9̐<^\"c*{Ƈp{Yg>OIMk_ @@,@<@L@\@l@|@@ @ @ @ @ @Կ- ʪtc/@+3̿04)` $G2A|D3,?cdkĿk%+0q7O` 13B&LB\Ab3,4&12+/T"r7XBзo&t}@upq˓xs˓[BrtLJsq[g\0 dn79v|{H|GyH}<iԈrs$ćs[G%cI0? *y `I,%A(GxDqqxʢ<} GHhJIyI;)(GyPt/pu8E ɞ<LJ| Jʷ\J|4 $K,ɛIpDKsIIHH<7t3(IJlJ+hp4+|L| H|(4ǟ<͇HeB3M ʷ|LćH@Ƭr$ML2ŴCIˈL10KLxh} 1~}L#$|hMyJuPqB|P\?\ J|4K(΃O|Ol 4'{NΟrPpN<\̋P|;|}|`DKχy?TMH{aPD= ]5Qy]QiQ·QUD!UЕPвP) lN8 uqEJX0S$G-LU{LʾJL+ S45>F&=;݈-.BlI+)-7to7/]5+uI!=wH* +}~IЈNQ،|QUm%^}SB,ԃUZ%pO@JR|VoPĂIvKpTNS`<0Wtl1eN qO9}U,|,epVMpWy WvMW9Xw%TlRBV`(}WBlV#{4JqMJ7v(;M$̶0NEE1pKqӆY|X8UK7YKB1fhOYY YٚڛƒYqsѭ=7Es[Zf%Y2s-a[(1*Јx\ W4Tt[1)!h \܊ۼum=\1\Sl+#}ȵB-G]5]COU]-F(}]]ٕڵ]]] ^^-^=^M^]^m^A^CD\^X^2^Xi+- .^ e5_`3cj{4l3kK`j55 5 5 ^`ak` v``` . `]``&^aNaa`a3:&:n8{9.a##6$&FT*:!~fb%'b8)8S-+&3v4b/2~5bLS;BS=d@?.;6;KcB>dJKdPdReQB-T0=⫾WV>YF>X^>`:e  #25UB^^d0hig1_mοlfofpgqgr.gs>gtNgu^gvngw~gxgygzvg국k4gg9,Ճh&h0&(Uӏ֍Af 74بPh>>}ֽ?i0=Ci@Fw^0ܗi`*96HPia`5e8OɤG 7H/jƨG "ԬWs뇈cҏ*ֈ֍'OaG}}!ke`ݲ˃ l=@87yֿ6kZ[^N]:ݘlĖl CfI%jO}$f%Lp~Sڶܾm}mqFhC(!m6HCVm󐄖pdzm,BmN:ixXЍ~SnvOv յo">XI- &,|( xI$᧞Btl-֩oR?m+Mo  LhX՞pT2 WN:.pqO'$r1qhq ˵ "tLOpCB݃N.nĆ8&pU`EqpE '݌Fa4Ws6P os`у X g\Ƈyl_"sqbe)߆`GIttq,-gpF`q9_V|EQ'up9QUX4FMLRP5ʌtMNGINHCm)M׬,b-]Ev&MS|Hkhu|U7lp+/.dOp1f}~DwqQɒ$|GwOGxx}ي4xtH<}eO8?-gM%niWy7iv׍ؤOjSZg3o|oxybLJaPj}&Oz,z`xsz?ǾćTЈ/N8O?' 7sun)r@r|xL]xTJd˱.~LMW|*IhLK|n-LF_?)4ڿ}w-/4rͧJPЧv z*)HY |}}nu~|la G 8{eH/4WPgiI „ !Ĉ'Rh"F fhqO/>g |8r!LA=1g @'χHzt+w !3|T<'pL<YQPq 'lj+ӄ bB4y/`K!"NC- 7ًhw-ާ& V 5ZU_7dBU :4IX7 4,`J=jgbAFxd׳o^dIcnx1[LSEN )@8 CPH>p`Rc(P%ҁ( > & AAA},M4"( 03 6#/㎿]fs% [$$eQ|mBH4FJA:`y@>&>jK wP q㎄86 ")B2A72>\ԥ|zBJўgQP ꉏ$K6IeB% _Xa*T6!:N+AY:7EB dOic! Q[|tfOqD3,#D,, "ֿnt B-i媌}z#=KѴ8*oB#v뽼"DUa .QUaU >/mQJ }di=5Z @]kٴEK_6E~P"GY~}7~ў#YIlyq#PsD~ײR^$zNpۖg4/ΡD7ԭn4O_e,v', EB)-BLAcRqO4B2M!` H%KT}A5n~\;D2ct1 ,!20tj.!뤗evQ /Za cxFʖ !JݠE-i5V3 `5`ԓȗa 68>Q,(gr x'J4eXC&r۫J,N $ S*\DxC t)Mɢܤ"08F`"~dH-q#Kx\N2FX2-rofCƍiRSM\A`)K2hHVkg(M1r3+dB4rf>$4; |dtA!䮒Y"DƐAtD- |.X 1op*KHS,Ӹ61s-*'Aq(ZqF>2%3N~2,)SV2-s^2,1f>3Ӭ5nJ1y @C29,!XZBmhD#Dч~DߊH/mL_1jA_ws hH:!P]G3ռuE"=ihEh `!,X6B`,#~(v6][fOܠQMTDt)Nwp"hWEp" ́">Լ-Ty<3kcn>".-BQBsƤ VAx!J,xbE<|K`$ʡ8X"@,@U@وfMc;ʉ`K9cUd>BP8rD@Sp)bFa55#"õa;|ytGD#GIM@SOL$H4hb9#>Dn$=N~AtT4ʗt6z dHF77Zb`|]`[mF">1`01QHDBF epgpehmAnFlhS%nZ)pqr8,VY~GQi vhwhxy@]I#\QV Saޒ<UE f&s t2MBTΟ0VIJg$ʢHD.E@{aR}Wz1zGV|D/oi|VcnFҧ~/pW9///Ư/֯///00'^Dݖ\o? NuϚ1A@[}0&YZGl0F0ExB0B蚫 & O+DY?[Vu)1jƴUk{(S\h ɅZ%eK%\1YĿakM+D ZĶ™q%qLQ\Ar0<*ʭ1d.%1K;i1{0X^모EX]]],e+cD.Eq %}Cu rΨU-'4+Dt +9 Y,2%)h2XJǞʴ@}!1irGtb`F@Oh?kDh_p_Fe-|JA2Fe$5BAF@,,2C@2U j zFYj!: R. *DPKP`QTCd_L @_`R#!T3t:5ECGDZS a6![mHa]!SE!>,abPDI5Sw K! C4DhZXAj\̘(6+")E|6[bX!AcFb& 'uq~w@F(.6E"+G7)7,f,.6Ԣ<ܢ**.Z/0&0"11jw2p3B#;OodlB'+4ffȄ<:Av4(Nxmtc]v%dvo|s vCF$/ b}x+L鼈$Ad*8JJIBs$Mθdx{zÖ)QxBD0ez ZMAaNea@(%1E8TFR 'eE\*fWi%%lĝ%``ڤa,DecR ֠[ydvg&;fyJki%d bODp0jV&+g$FnUzOƛnfpFx'qiuID&+ v"vJgxBxBxDz³;'A| nz;Sd(6[ wFLyދv"hCʁ>(ojjZju5Nz4E|o{z2JLV :|{̉6ʨ=#O-{T̀!u:hz ;JV|HLU7e; <}C <hX|VB &ģAܩ}p}\+;"jBW$Jx=㑧~]:3nL? NEZ|Cлn2+2jF;oO(ԃPW% k =?7%w'>`kѶ"D^fk쿫ҡükQE1W@Fkk,קW,e[v΂r`/%0)RYVb20? "Zl,)ɞʎ䰡BR6dXfEpX'oC^["cpKQ"|)DBSKL$MT)>r4OVzkV[F]kVd5QO )KH |L:0HN*û@6vX`ڬ _*rY 3' @oᄰl(z$ɐ!" B P`llG PA.jG +LCR#E*PF,ܒ.䪴Ӧ2<4\6|8圓:<ܓ>@B =D]F}H%J-L5ݔN=PERM=TU]V]}XeZm\uݕ^}T W-֪c=TUeVZkMI;VomHq-Wgv\]vߍW^w^zw]{a߀zW`aVxb-&_2XbAXIvc7N[vڎG^QcC{码d68fNE獦 !ZkZj.lflVmonnf٘ooR 1O.y]}mރp/ӄ?x片yӞ>zǾz>{ݑOg}'?~?yԗ?| X> Ѐ+`x?2<|Wj 3!viN;jB“ Kt&OCɇ!"?aMnɉJD>UъYE/~aXF3iTF7qXG;yG9* x(c%~T" hpC7V1d;2)T*\ d,i *hnN#!i Y|!1bĐ*a0Ӑ0bY,(iӚ1 ~ '4$&CUA:Y"8Bc;  D@%>pr& A Bʒ@$h2n$$ *fB)Hy;ʄbz)X"|a DbE{8@A/UQj"T$\>1t|iLJG"djzS. $a? : *5JTrhX0ZՈb(0$:A@*;*#>>/# Qj-b"gd.C@Gz@pXaFq* nbӖ#!M(.g=\:Ed@V |" :FW  @%Rš#K&d0dwկ3%e^F6'C^(*=zޫ4S_Giax 7HYSMĄdrj fH쵊ŻHC$*@4,.F@ 8DI`gDzA@ر߈HV []G F ]Pƙk` ޘ lEf+&vG20.!ܛ db"KF1] &<)HIX'Vz$#2&.]jR׹yk_]lcVlg?zʾ XH<0v=g‚ !ge>7Cmn{іXM:TӱIKgorKǩ/KX;p|L2X<9ұx<&/!$B@I\!9db.~&k|H҇.P+<8@.uS};:X3J@H bd# honv?yA0a `8 8 Fԝ,B kmvse?{מu I@㱲m%M,yw ER3[W}C$-"b?'ei9Wv4 ɽ'GJT`E@_iHV~"iA*QtωKԡEtdC<*&A 親d# 2BDҋ!#J 'P +`=0*H/Y_J0!*!>#) 4L y"0άB” c , * b?>a)'*p 9 PvPKCС0'VD~췌o 101(#4W>LYQKN1U̶n/EN#* (r8*!61 竾Ba*ꕨb!oѱq+rQ2X",(` $̖H@&!&0𮈑!C""6#?,B 1PDPL V̲"Q/"- sp!&R Ȅl  N,"')g *qx***@*qǒ)QR~@AA㦌,%־S???@T@@ @ATAAAbD5դۼ 3޴bCC"BA%~/.I+M4-ʴD8IF N *:GZbdB1DЬ@NDJ b*Tp.!2RGI4$H1d.閮K!J%TP$Nv~)n.`.#K)"(/I!&/4*"u4*DҔ֔&b`vzΪZj8-h̑LJ}*OOXJՑSO@uZ"ir4/3  aG!/V=*W]0YEb^QbStYD #=ƦpR P 6 02 D =2۰*PdI_=r+`- @fDW6=H^d kbb?q\ʿgc6a1YUn)_vD ѺR+K 1OiuK!χ.諾+Q)VWWSKkkն`s&¶&6 l[K6Vl%8$}op$1re)0$! l*U+h'&U'" „-mǞL͒8+2+x%WmHhtyt-7wy.:LlWs(lK23'4s(D3C(@#b"*4 7U$\O 9oS0r7v!@$X8!IV6mS9/h ::=q333@Γ*jLS$3+SCSDx8XX؈X؉ }≧OĊxTRy !a2Wa0 ^\#'XŒL&z!CЎ*C $OAn@$AZvD=2y$*"XirK+y?Œܘd$!TY$ aM/}B!y@&,bybO{29]5^e Ԝ$ye C׹P>y` zDA0&︾$95Þi!P@$BZ&yUysi!PxxA IAg[JbO z0mBn zz3 z_Z P` ZPzFٓ:_lE؞݁!l{|;ړa(G ڕCm"!$Ұ5JI=9/7{;c TEk;-aibO2+*: &A!<d@ۮX0@h4{3;<ۢ3 ¾Z"͛}\eYe9¿ؿ bjnXOj.| !Z[ @ b.[Z_̻e9e{+)<ݍ!8FʕZ|+*kʷ@c|ȭ"ɕ\ONy|ϻaݥYכ!@ښ9ܙe S9/g \aE"ANqC{{_[ݬU,} ݯ+ߴ/5+!eBS H,GOA }i 𒐝k'%l'*,&*%L H"I>8q&Pd q*92 aNnjԂ#v PP R<0+Ρ'S&d1TWQ;{z;@=lŌ;~ 9ɔ+[9͜;{ :h)j#8Ъ믣ՃʄxuXTngP+ @雧S(ϲhs*˜l  }#mM7YM̡ GKy&NrSemh~b"Hb&(_Af4$eX``-#:"Ə# 6cq}!qbO9dXX. ͂c(acwg~ hVf4ޠZhKnFB?('x zGy.iJjX*޴f2Μ&[*j l">eMAAAQQQ_diuuu{{{_nhKtZx[g@pH,Hrl:&ᴐ +ad"E|ŠH"ǠM."m7X$J#$!yovmy mt"uy{|zQmJMKqKA!?,t   -,-,,032332;98936R2@f2CiCCCKJKQQQ^`ch`Yjptqpm{{{fHhK\2BNT~tD5>GviAX\_+ j;<B6 bS  m#"sy?g?HRA!r,x323DSgX_yhKɴõp2Hy,e>j;././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/screenshots/tables.png0000644000175100017510000016721015101406164016705 0ustar00runnerrunnerPNG  IHDR'MgAMA a cHRMz&u0`:pQ<bKGDC pHYs%%IR$tIME4p'CIDATx|\u.*wUVUЂP~H `~( ޅ IMSBB̏3?i %Mi:4$4m6ipJљt9g$yx>ܥtg5?\c$ROEAEͥ1;nx?%P2=ϫeW NC_Q&BۀfqPP^7q߫?kb~>!mWK!>M؟_kwZyn& 'U*B~0ÛF~~A1_u7{xLaKw2tw{~i':mE|^U@ Uo 8laƣ:F{' Ml?eWg"; Npo`>҇ڇ\o 35[El>O@$sݭ<:E|>H90V54;F}/cծ|!?o{EEN9JUG o}an_Иo+?ߐo\G. Nv+fB|cwEfk⿓olNv姆|.{6Ԯff,F@+軍nCUķ Vi`9krN@NYWUF}WA?ߘR1lNo,[z1>夵f{s*#1lalƾӨGQb~|NB~jķ v>[ PTeTQoS㾓o6c?uLDl!?u7~NԈo xo을O8 `ˮ:y,[ESwy\fgcܕ$7F|7.̟n >ӎj`0%q~o7[lO>3v囍ֱڍ*1ۅ sTԪڽ1` V;v[q[Q?Q;*cծl!*|xo v3>`ȧZV7 .~$WszwәFCG5MoHD".pXBDQFw(P($pX|>a >`PB&9~%ix~_@ڟ}M?V]קmD" EǞz;uuuGuRSS#~ZDQF[ Z ӷW]]-~_|>qmmN?V?}SY6C3'O_3ZG"ks!LK'y`u42O=L?L9`p&{$4MH$"hTꦯk~ޟ^Bu}>_\J>wߟ'~y?^y?^y/_3?<F8v~Q]Ʌi%Hq[ew:jǫU  ɝ)xI nwSgOOX UOth|d'$ݥuwQ;V161ۿRMΏbQkVQY;;騝w*5k75XTBR5x%4o QOnF{ev?p|>A?i&E}yiw~.vfg~0K}2 J(bQf$o~C?O!2zqw;lnY?bg~2"qN4P(QszMhƨ\ynwޝmN1 M>DE O躞ܡD7?Y.}F$cGs}: gQGS;nvޝ>p1o3@`пZv;;#Gy7?.}qyww&edg\?C[/5MrYş`d,[T~d,Z |yhM@^)(/n~[/˪ǓkQPW$OptgK.؟; >v\qI +cYp\|gKKȢEg? sNw*kvV(`08/ѽ[KT\oO??gT9ċz])?0_C~Po|횵h2CM"_3W$y'I>y{~}YSu<yIm6MFIM.4Yp'3&/,y0kr|I\KMPKҞǓKmyuŚy27ɛ&ws?vgǟK4',uϽT)ί~ak>GJ>&IԷ:$W.}ˠo7n''8Gď'cRcig32ܵM*0*/qW{ϗ%KΓN ,y)@Zv>d>_Qtm y^f vW2-?0_|P^!$_e wݹNyV_GiT}b'|fàїf /ܭ?M~,cݷ8 n>s~?:~aF}ߟ~!$,Ѹ*%g~oKnNv'c''g|M>7ML]~WKG<mU+cx?[onOL;2otIwox1};goAM ?(Aߌϋ2k(xͅPWk?A[ޗwLa8}N7}fѕ[4gn'Xox] (525Y+[.~,ۋ)1O®7C%,鉖Sjpη۝o5jbi_KuykbJΌv>sokhT&djkݘ7_:^^ ?2''3~s\a&6ۯ@^ǿ?VyIirN+,%E@z[v?/Pwq4M?"o[&k$?|ͻh(݋5wvzXi#?9&J7>mo=p&ן',gǯ^/ǿ蓑10^XQ6w6K?ḞO?RF|\3iMH$"@E5Áqy9QY zA_װiYF˜YjAjidǭ1 VwK/'r"^wgozO~^ N{w\r.Fw=u,]%5r 4Tia~:lrWk$~d׍cƯIEb^4u{/?G6%-@ }_ʤeMky]wڥSEз۝?Rv,K_iią`08o%;C9zEIDC nߏ}J)X ^51i{Qa^7Knk+?e,I?xSɺz6AvM|M?H'0~CcM>ѪdK٥?7 7:n'vv1H$">EE?37 LIvɡ#2>>.[d[^4}>A?? ݠ03fQ\y߿$&U<O4Mq:*?FЃ7kзU:0[߇k3$x;AraQ>b)bMONFݥt쎒q;nvii9}) * gJ-|l겮!]n&dɒOuY?{T7#ryu{0m~7Woȡ#r5Y.nJXz܂ de6+_ +V~9x谌]ĽX|펴z}hRٶ/?vhڥ}, n9AR9|d\#G7e綐wJVV^;$GÇd7dwV<|^K.kB7(eq9rdt*|fFy7NZ^}C1y^j?[-MIˋ-(>MGA_?9uKeɢϦgs6EuwŒvWBw˖ܡ3#;Y^kg--F$WȌ`/~-=&=V*ɯv(蟵Yd# C/%?$Zq]*4n䔠o;#9O3=7?qiڗUox\;hʸB{&?woMfg8<;L^3_Oq*M%2:ew.wQ<%]_iy狜ʦӅ35"}I룀A?d&כ/ltuɉ+~)M}sڕl_T:pVߣ뷸__ܸTLde6y.w/oI]~xY@wڿ9Ε Z5;3~Zcy2$O2nkEY)27>`3 8A_Jfk?p29Ѧ駎qK#6ߗsc1۝߳7?EMjv^ay@*ۆ%A?bh;l'RMΣtx"/+}Jcr9p`H2y`r\/08(Co&-"Yܨ4h%\mE{?V%wWu^/&"Syx.޷s|Gw,96ߵQzxe:[j-#A].7,s^ ^ެ?ϫ/ 1Ŝ7%zZLAz3(?=Cr"=d?!:2k7.6U v_7N:Y^~o\zmxSly }ino}A`~O9/ѦeOcK[w3v'-;q;[G휛h^"HOwԱcNNA$DzlM;>EAo돩CL[ov{|OKL dӐ*?JƃaQox.o=2t(nY0랴G2H?LL:GG~6iq&AyP/ S<7܉wdj꘼d+z=_Q7X]?xyx"<:cJQ=([DWڋP,ߟ;575ݷfFv_xv_GA8}/244$C#cts~3~h(Ѧh;o]ǵcx{I= 7v4M;_Ӵ hBJo!Ub"? x#ۏ(>yqcߏ5.D^ٿiP;#A?efܡ|R|7S~ZH jv^l9'%{'[~~iOr`۠c1Ov_qߗJ/=[,X`"s`~b6m6z']M Nx2n';f;x,LX"MӾ 2f1^k hfߐϲ Gj Ygv91 ;ny.Nx|و95MmJF+?-OS3=ڞx}\*33J=t&y\q͋\f['i~aDgqme܇&ތ:'݁[Uowߕf_Í>}`0XDN97Ѯv] fvM[Q;kvi_Fyпćw|߳ /'fRCq_=g]SiAc?L.Skb0u&[=w"|}旦ѫǵG~%:OhyT}2?OM.~=(Uϯ<]T囚6A_zV^N9Vf=&;s4yHAoYO5={\U/o3MQXd~yx~to|e..)~Vh>, . #2o+we>6?Ѥ8ߣߕ}ߟD>?e.M٥pWA?It6/44M[ % {SsfA?%&ņΑ~X79-Si#vcn~rǧP\7<ڙyg:ja}[LX{> s\/y|hd1H7 DM%˜_zwA_zVT_?osї,^&L|EgY_terC7efE0ȃ-^" ^#y?3AqA-qzf*̝}K~iZ̿/$v'6/N lv/H4OgN>s?9!q;v&wnwi_D"Fsg.7qHfA؄I r:AA}nӠѿ;gigU'Zh¶Ud2s<;=%vblBq4ȫQzI~/]'>ြ~T_4˃OB}/ֳy QPhtRs!9tN/$˿𧦮<] f;kO?,wGo0\g]w%7^jqF8\+MB} [5?"Lx3~n Z"g}g>P- %7=.ϧwz8n;'ҷ8gQovnrw4P($Hk}A?= d]F}qUckߘ m!oI{NGKe&}bݵMw(qfB|z|$-_L98>z٬ ^tf0O9V Aߋn~ޮgѾuYwԏ迤`~.a=(?Z4[VCs{Bٮh̊/i,Yp&-?X$&o=){&hWn=98Kw$g}J>}.H4.}q͂GϷzS|Q;~jp|MӾr]QW9}r>n8 rEWv"ߠNXu-q㲵;jQzIP/KGmE޿T2? ^guO+z g{l]e}&OdUoo,LXD'?MOWgG/^~);(,P>|Ӡ=6ŃoA}ȝora'|^3?n쎪9yjۍ1; wQ|MӾ ,&%諈AdžyPjY3ic:vA,@tpUs:GW?f>seyXP*=As=AzVT_­gA?]hy xgS?懥}-1q>*,oc0nj̣oq[cWs+[v]3o+cn<Bf̃[3?"oo&tK>p+K8MӾeإH?l9q;cܝinf'__݌UuhRzщ)9vlJ&,+uۓ2ulJ&.ӝs7;G=}}_Wlvyf}пdLJaA o@rZ1̿/ -ϗX~IMw;c7G_A選*v>gܝUMYӴo$ 4H p,_ dӀloNrU}[r@yd7mr̆G~1~& A߃ñoR0~qQ;ǡX#wz`xBOqo2oiw@vts] c6:[LdAM6fNq)}}̂ L贼~ ^oq?_=Պ03 5;zVT__*V[A};3J5dQxJПA_4`~ptH$|!{}>歚s&r[M[5_6g}iwߗ}"':mb-pԱ;9ɱ;N'u5>??uyq;Lhÿ.P}8l)o;`;wDZ=9Kvdı*@w8ҵ01>n5sOW6UYٲih*_o>sloT_,_~+fGQ7V?AzV_?oxM9nʯWo+VK N\q%qg:<=G1QM}q;kNП/A_؟,c6vGnz?|8Kqyo=ߗ}V8ND6{؝K4hz0@dOO O g&vA1nGӴ Br|nIoޖRnO G;;;][vi|ۤݩQKdбcrtj2m@{lʼ/? +tgoj7w$redgGƷv֦CmY9xu"k]79gt~@DdJD^^Xãv>L oRLv_*k`כx&^9[cjD'o/Wlz{Xjןo4-KOguf}znE#5'hrȖ40AVW#fiw4ڷ&ۯc{JMYus4Mkڌ]kSs>({n9|&g}4ŨC-}GM+c~fAз͏ʢ 䊛#j ߟocwOl؝)AqCO r?7끸sQr܎i/[fޠ9`Ma7Ѹ}{BޱZuվ;-'dG媔yuKC^oc3=ů![Wm8Oã|(~>zO䄼ָuTnqpztllGOs[/S< V_YyţaF-gC{x~Wr{ h)i5-Ӥ{$7!kc;:N߿Lv;x7 ^" ![_2|#k5v&7A?ǿ/~/ݦ<%0G$:wR\2v'9GlNr~>z?bS="'$=1ď6|7yͭny$c+`/ͨAnsmc>U[4ە2ދ@~FsL#9Fo{Nm̭h_ŧ+~'{rePy^T>w6|?#aO5M{7LG~%3}SX^\?OP?ܹGo/#| <qxkfW}NeoI7Ϗ=9_3{#-'Nk?:I}S,_q)=!7&Ë4Խʃ}@ ݔ;'uA?9G`SR'1 H qS݁fOlK5MWM. 9% mO5=qn3{,/amadޟ˼smF7MҶ_;kDeM%6>F1;[eSψÒz@¿y0ȼ,/"ofm9 d)ǜ=}RuB寏 <~eq][G剻ruE%cKd!kH>;EtSk.K4M|χֳWs|]Ɓrdo+9}g;^|=Uycm]{_ 9m4SHIu ˍ;߿P޺mn:rxءKUnbrݳz}ө$Y]Q&M7<׋hƬ\voYnx\7jw%n=O_J0~{ >KmDFm[~0e1'[7;7ߟ%-f/J&vbV) "=}G:Z7K/npf('▻6޵Kzvw>Y2ǽ>ɺgCLLLGߖdK:u?{X^{W{HSz޴1A<g^]dWRT[%N-y>Ζ+B7dҳk.{cY+)8tD&&'e"~D^oݘ^%6>-vɞ==*5K׿_g%.>vrO5k5kJ_f)[tR/'K#&?䝄kr&MzҤ9'ɏ-{&?>gM֟mD,e/7i2㯵k2#Mg}fì٫d5R_<5̾0^QSSyM;Ѫ/g;75 O Vf A6A選_KbVR]ד;?5,a=y*Pi36v0.HD4M[hvbӃq-AC9O[}へ5M" ޡ?; sbgV;ik+wѮDo7++},~{ >G0LпBz0YtAC~@OhLJ'ف_NEf"v|Vѕ`0CqٲddgM~irQk|E.*ّv%1&z,`66\4ؤ5~?9rJ}qKm)z0&OM g?hO^?DB jvU$;"w׿YXw?P\?3A0߰^ ˯2Fa_h  A̔jb giOBJr5q1~[Kih4Ȝ>A ɋ _f(i7FcG䥚{e|a{@1~1{ >G Hzv`ok'D>?ѶA }Lw+/┠<w:_/k/H}rh!~[&~[o`KBkKb׿K|)闑ѣrh\W_nvݬ_yo~,+M 7yJ[dgob1Xt5+}A`u=١A?y0n2/6/ow?b?fk1%/J {ʏ:P0}Wiڿ'tjп8%/J h?f?bVLA3-4s}JJSJпD;~zeAE ς~bcy2_h՗J4O^tASGSL x$.׵+5MǢHW5xȝ%tjfaSi%Ѹ'SL M >AkӃ  ͂%^<Aă=/f/4*MӮ FYT*Y 翠gsMM_nh%9A<f*&/ r! }BPrUE_6AQ??o/L 4Ơ >OL8p8lhɠI|J 4lC_hiRMӮ4~_ @ It'D AD A킾wF }Oy6['i6Aă=?%_d١ }BrQJ??Ѹϵ %Z-MgS_b 0?~E@l~^JFYVQTK!OMWPVyu<.S24)JJƵ-KBA ./!4[< ;[6Cm^YJ$C֟;J_G6kkkD"fAf=k\0Z+4MwMӮu]t]gQgoܛ:7|wv6T¸So>A}96O/; @@B @;V2Hʈd%A|tX|\z6"~Aw'&8 _ 2!迯X,lA;UY@->3 [/A? q(.OP돠>A3h4١gm?Abf>;5CP돠>A #wпAd/)w}ߟQn/7KIKmy^JhH:(^Q%U:sFj9Yro}TU:ǵįW1:%iIgtmS~,mL{![et~inNj&|(\ +LTw.;]W9߈nXez1.uQWAߣ~BDK3SBп,.`EA48&N?L~E#͎7[c[Kiez}?s'yLYNsϣl{]Y>lx0DBr|([/ȉϚҊR6ʾ8 +ˎ߇WҢS!_}OֳŸCf%)"/ BXT94 yԸc['cc9;o KVKy^VWR%C9ʸzjeׯ⅔7eUe@:&?g+(6|k|%EEpof={_A? i\r_dUӴ4MRӴi, C0,؄ x\SNw?k3]_?hSz".C2dAWӸ=ˑ:9fr3%z{t e |U=ʮ!w7&lo˓'KA_+ޠzV "mDWhI07i_["mYQffhZvg l3y{`"@;ҙqL}x#i?Gxj_lZ*yn0A_ky{ }미;(h7<ˠoڠ'mg+~7^VU|(~_j3 ._}yƾ^?A)YTm犛N˾ 5C9w^?cw3iG;U?J_.AH| }AD"Y}7A?s(.`jl;+F-o2v&7 }χG/}ANW#3srN|p}G!~=lsay_b釈{&l[= +J >JA"2C0'~!rPVZkZCq 1SwA_;==G?A~.^3   *~0$D*Ę]z2wX}4Z.1{7.}ׯ*cDX7d:es̳Py qA_zW ] *Fs"藔K0c,HYesu}xtO ime䦆qۻ'͆jg;e~}7#~hgy>^ n/UV,YdErц[-Uq&Py^?CBPCwFA|"[L ږה6oSnzfST~fQrB$64$S&~PVytχ7cA*A#>h}Tz F*gQDJV=݇ıPE|a?\584MʲRδ98EP=wy' {|(~/ccYR0كQAü ٮ\W /@bN0DJVˍ^yqIo ܆,3smYo\9hƥu[}ڜ}ay3Rf 6qx^\w: j)m! z_lu+'5 <{>?gĚݭg_o H$ }A?evs&k%E+,u]R.k9H4VmR%um>x8fs}E۽6Tw풦v!M=;e\^a+"x150GߜP+y@/p*~4e`nk.Y)}VYQRJl u;*c>t*fgd;*[ ح]m vQuԌdH,|{~F' 8WEOQ&/XcyAÁgmd[<0}k[ r5y͌;[|AAMAf~?}ctKBJoL6uKu[4T渏8,cfsNFw;:7Nw;r' }cnƁ2fy,39WAu=-b)s l;IKk[Ax f}v*m4Ť{hHb202"CⲹN Ƚ/ɦקwlxXz]VE@Af+O}W`,W>O@ @w A@ FQS# u]"A_S0C?q! 旆jw}7A?3r@ QC }th뺄a = Uď:@ }A? 2r@ }F(@+`R47ʲACW(;}A#=*d$emr}Ow'F5԰A}/O,'r% Py!胠O  nc>`*~ږ祤Q䁮UrQ3gqN(GZ_um3y\Nzï_tKg6Ŋ߽ OrƴWɽ-PvJG6Y{x_Yf-_._J,~˼urWcpP:c}R*z!Ϻ}7A_u>` OK80 Mi-Ǒfѭ1r-ǥ4O܉4ol%#Sַ;^x-+*Jg0V2NK(Z-{6m]n]yn#[eӭ==_7Is;˞]O̚ǫW ox6V:/Wxy9qUҒ cold;YeUMW^/NWCkAV[>ehtTrCY٧8ؕ?QMvf R}ȤuevXKuoԎ3QiK:2sj|eoLXl20/U>?)>N7u`r 38 a ;7ω=y=bl2ʵb{(g>7S9ZfyNӯEkƑ;ic|Di˽q8OØw;?rrnˋi6:ڝ6b6Yx=۰]63z.A\ÓYo[z!Ͼ};0V$ >ԓK7,WA遯RwRZ]W2FoyC3#>镌("=q[;~^1Bgɓʻvɪ kf7oФ~,P͖?0jGdB0I녠?FDQ A\cjDbͲ\.ӟGˠ{J2WkKD(['75$=i68T3{clS{3wvhnl5cý*OWT[Ey9E{eM#Jl%L}0{C$ַMeoǾ3u,y^:4OXvA?>)*OYeɏ.rg@ p6ֲC0GjGۏYf4Y̲锛c{TP/_yٛ204$!2+2vruDKodXvxZ 6uRkFȔ AK|*w_6y=ׄ%zg}f+8]YrOa1Xꞏղ>&l3[eaY\ZiVZ(B//~6.`n0"iģH=CAߧΟ~) A`; n~$I;m4Ƹo=⢊57M=Zܜ qizAYά.49GEElOm'p}"uuu"wx|Tzc]ڥ)_Lst2CkG||D:zDok.>8,cfsDFwg=7o:>k{Q*vCicvo+rE' *~0d>C讛Qkq@~C{s Te}"ۋn(v }t]P(DW0 @зCc{̥tω7WG'9.m rQ(ڠ?6[VuGä 0;}9Y۶Cb=4$a!HeSrq \UdSӏ;6<,C.~B*P$o=t }}ji]6Zq[A';%}GA).`E }O}A?J4eQ>A߳}7A? % P\U#w }DQfke>  P(A?0C@ }F(p;>OL0$ }W|>#wTE̿_祤QUq;R;xHSS26>,52L*erjB;eYI)ׅy9r'&GQ>`ɜo㞾?݆L핥D2$ SHf n~0$ooܛ:7|wvN/*բC@o8UV. r9YC?H$¡GϑB8}1<=uq4IFRw6|?˃>* hE *Y߷_Fq_ >{N:FFe,>.}bày * A??h`0F}􋝮Mw}>;6C =ҡ n~0$~/7KIKmy^JhH:(^Q%U:sFj9Yro}TU:ǵįW1:%iIgtmS~3M߽ OrƴWɽ-PvJG6Y{kbau- HuspP:eyEi|#EbspPZ۟vχu\/٭׊A`#w~?A_S0C;97<-Mc4W4lGb߿oDJQ@N앥~c.fGomij|nYa:!mh}耬,;~nk3W'_I Ďzg=lvz$vTdUχaןYy#Wz~듭}}G\8([{zng3~Cz[-=~A "#wT@ } 7HW24:*CqO9 ϚvZ訌&k^6a=;a9E['#LnfTzDoL_Y~ͮ~yc&rZϛv=^y$e$>(XϏO;ܽ{>Ԯg/^wv6>M=}18N n! iN `QN;MasK$#]mr9j6fy~cƟY:#[ψx%:eoƁ(~fu9v΍n|$ޛ߼!Z>>:cY._I{+n;u}h%>_)AR2P+,.~>nTg/CzVIXWYn됐\}>bA0w~wO J9֋: , yП-J2ƴQ!qy,#f~6gc7;ļprCۧwi^ldz=_Ϧ=q[|l9rgχNj'LuCqUI3ZFb~hGw[ަMUy&S2m]q!ea~o[}:t:Gl?&{-mzk=9ͣU|xU~3͍ pb~bvf2=ҟ>W}wkdmx}C5>PAߣlX^[z'_ Xj_w?7nOpOПQp"~̍_c .d?8 };\~[ox_rC\_Lj"`WqMIH/+|j=gOV4Re\p빘Y:RFKs'HA/AD",*>=0tf]Ƞo mGbMcگO:/~U=~gXea\g= }ֳa;Ƌ\AߛƖ$cR' &$;4AY`ܜ\l/q7ng˓j~|3^wS~]ϸ gE܋\Aߋi:|T}GȊc_MwC?q0;=7}3Yk&sڡ*+~:w8--}۠?1CA߫UWgOWU~|rC~]Fy:҉OwU}]% snN|p}hZ c}XC}d~llA߫QW ik!Yꂾ\蠟6gd23>A_EЏD"ӅA?Q9(+-b5-T==d|,!zU_s{ =s$S;WgYQb=){Vv+Y >^ 7Y rEu`}Ip'smmoXN.h7=\ccsK+ _U-6S ]6GON(H$BwCA`nq15 k[^SG߿N=OuE А OAYn V}}ֳfUgC752,;e`tA-ϗNw #ws*k%me8^>xunCoc?ўav\ZէQߗ:Fh<ЗYܹ {=^/C:!oLVimx d[>i`ӮӨuidzl'{mmT=5~glWevLHpFzNl]mT{7ڊ`09)6'~9֮,u]R.k9tiaY!u]]R&C\?ȕYosRݵKۥr[4MrA;-3:z|R|?Mڥzr_?sAe۸EڥM*wHSNZdq~G|OL!k.g'~ 6HvJE $ }>?;mƸ ,0rGE AdlEk,8h8`s|mzAU&vir 0;2'r% K8fQfQ5qh<>*1.m/cS\ 9ܫǚξڤK˘Y@ПR:4A_sy(n$aQ@w, ej,3 n~4e>u1^?V޼C^tx츴5AO3C_S4CCq} Y۶Cb=4$a!HeSrq \UdSӏ;6<,C.~" @'4r ~ Ϣ}'A_S4C}A bC@ @ @W١ }/G$:4AȝP(Ģ}'|>TWWU,*A@'{C?1&aF>A33C_E }τB!vkfA = Eu }A@'{%K("k e>`<4?/%͍4۩Ca$a*erjB;eYI)}0C_ą`ɜo㞾?݆L핥D2KJ9uA ء"B"_oܛ;7|wvN/*ٕNX}H0P\U#w~A#sc"p ߟNwC?ZI/#񸌌K@y듾cdT۷].暀Mh4}>_ A@' I1}Cq}>_B#wTp8̢ˠA}麞C'YUMEֶ*Sn{Zw+~}4Ť_:D߶)&ކdocثޖ?(;PvKkw=>aJj~I{hHvKglɦv)i|JU67%O?S\>'.K^ j۠{A48&N?L~E#͎7[c[Kiei?П{eiؼKFo[oy[w.,?6[VT@ԫ=e<Էmwi b{ v45딊}c`*~MMMtaTпM4W c9XNrw&A?VJ# KVKy^VWR%C9ʸ8ܪTxn3s\tO8VQO{ Z'[/^>@'>C?ѡ n~ H$¢̩c-24:*CqO9ݡSZl訌&^>d&2b`G;,G~v͌J[O]1S+LP5.'2?Q799>,]MqylCIA{OuW^z}O] HN! 3r0iÛ["m-3̬mCklAm&oL'7f#CPyXB;2W=ց97=MxoWKa'}{uHf$Kf0ݰ?"ǝdu5kz>A?;`6B!̡_%-"-n0ۨx!mƾm/ AyП-J2ƴQ&qy,#~6l|nߚqVA[c1o\sbrBsCõp@Vd@'+C_EЏF̙ٸWf 9bl =?6pg50n2n- => 7 ܸ!ۻk$-k'=uAߋ>A }U4r'q!A\c"A?s2Wq43Xy=ҟ~N:G;xTdnO"j5vk;?yZ|Ry=uAߋ>AmOL! `˞7r gӏvg}kormWn+A̟ؓJH?ȶyYd8%Ai_^MߡwϣSX/J_ ]u]A_Eg>`.ODG:mǝ:CX8{C{j_l0Z(Wvf-l8vtPjַSB|X%sY/*_ W 0~f0ߜn/qnlWA?v֙J_;שqAi:|4ktfٰ8jw ^ Av)0!N}3Yk&sڡ*+~@;w--TP+_)=.m(ɲCev5ݿݞf|}Ow#AmӠ_mQؠߖmyEaw}뗱s8g~V>yHITlS|g{^ H$Cwu]g`N܉n} ca]' #njO q.q0հ()Wlx>lX' 鿣BA~bR Amg`.C]堬״ nBP\C,ݲ0XuW}έ5j8OϑOqp0o8|n?] ^>ПA?q0:kMbC=|ok{rRxA遯Rc^Z]W2FoyCS ]6G< y7.vYZ$:K1e>cIʻvɪ k< z!胠_jwA_+ Hw3M /ɫwO sKMNYjܛgGN?.Y[D2AE$ַ4}oN?-OzzxABBэj|CRzA/~6B!fH_-S5AafcSnzfS,~foLАĆd`|ʪk>||TbC/ã2i{~z!9)T7DT?oYo|녠~q}Gw#ws&k%byT>ްWyЏuvz&G{eYIhzgZ\5"Xzq;}r_ea½8HwkrֆJOw7T>u]' )9r2Gr$vI0m2>ߖ6ў|\Zէ͵ߗV;F<З,Y {=^/݆yc]mx d[>iؐ˝-a+=3Jzζdd*K,6Y^ Ǜ@'7C?vA0ׂJm/K]WuƧ21:{ZeXֶuH]WԵɪ3U_?YosRݵKۥr[4MryͮV7rb/-R.umRپCzv"+ypmtTM;eSwm/JISnGzE'Gݎ܉D",* r[<[%-i(($UԡmkIDAT "GQ>tfS}M:lH/iT_g55#w70g`>A_Qgo=䢊57adK[ r5y͌;[|A}7U[[+h1C@.r'}G?&ڥ]beS'3~GG6n2f6ftwG?.P"'.$}cnVGō e%P Oзߡϡ =fU:@*ۛwȫOֶ9 OwC ~0$V*m4Ť{hHb202"CⲹN Ƚ/ɦקwlxXz]VED@}~NAUą  W5r'}A@ @W9@ ^Я% H$y0}A D&}* 1rGǢ}'(A_EFYT>Ogơ}F}O}g"HrR AMЯ =ۡ n~(H$¢Ϡ_祤QUq;R;xHSS26>,52L*erjB;eYI) ;>F5/nԏ-O|!6dj,%dh%J_G6s]١}Aeoܛ[;7|wvN/*مբCoeaY^Q.gp}, >6:@#s$NC'1uL/C}9IFRwgWu6|>eQy}J헑x\FFWF ôOQKov8^1U;g`>A_Au=9~^A(/'$UąOA  }7A?H `Qe?>@'{. %'5s>UMEֶ*Sn{Zw+~}4Ť_:D߶)&ކdocثޖ?(;PvKkw=>aJj~I{hHvKglɦv)i|JUuYǺ Ǽ)Nv>n浖>ǛugQf4 Ӡ_єR}mv|*#Gr\J+K>ϝ+K]22e};>zۺugݲt^/>ќCٴu:zo?扃^AA#C@зvgiЯ|Ar g;X$J{daj)OoS sJvh2[FjqZ=d΃wXl듭}=PFlӓu4?kþpx[E>A%ߟXNwS.$s&~j˱ x\SNw?+;'24:*#,AW=ڑc&73*m=]wI[N0ot6f}R%zcpXF' ߧ.??)>NĆ 㙿}r|XZdSߛ&?I6~A'CW# 0wiÛ["m-3̬mCklAm&oL'7f#u{XB;[flgXz3n7Mqw~az{uHfdQJVg} 3ݰ?"8WQ|: 0G~O J: +- yП-J2ƴ7qy,#.~6nߚqVA[c1oO:՞lϡ;cGPp%_ y }M P(Ģ̉ٸ Wf! 9b$o =?6pg50}!m]eLJᦿ1!7ECqoqkr~}bOvWxKE*ÎyVZnlyMA;6:(5 +_1wr0.}W;~?A_S0CCqs!g3 v):^:jn{Ӳuh֨#+rر_4A|%胠OwQfw7e';-f.; MCUWzAa|#;S}rC~]F>eN/dЏmnw43{6+~{.V.sӲud2pfoad$RƚM͎*}5A?53C 0~ơrPVZkZL7]{z(!nYC,:諾~~5{H88pe[ZȠ_ 8nm}~A?ѡ u`V}I|'sWmmoXNF/h7=\ccsK+ _UH-6oth!ƶ%.K˜Dri=6s;3xe|S OT޵KVm`>~bR AMЏD"R[[ˢ_R.15"fYXV.v'ztg:!-9l:n{0^i16)K{3bn<tyuɪ&:A'$(_7$U9~k c{eMJl%Liإ/"moj|}oN?7;[$OϋWCs 诖ODw㏩YRj1)7= \~7&d`hHbCC20>eeU5~Ic NN0#dRKedXvx}5_)7>ACq@ } Zj}@(7Uc]&޽^YVR*ޙhU}#}Q0O,Awg;ziﺻB;uXΏ >A?:A_`0Ȣ̙9% {nCoQ.Һ>mܙ6恾m:~N HnC1a.Y<}}խX4lH{Ζ؅fè4oi==[^k9!r5ĨtvJ烠O_J& )0gY඗]emSrq?ɝ>2,k:KdU}񪯟q{m9%MRCzvJu&&>WZ}/,6nvkoԳSYo,y5&mRy/q˵RپC6uM](% Oɲlj }>?sn3@kT%-i(hTNA>>A+>"as'PE|,Zek_,u6^GzkjFo$` f+HD @зGrQn7<adK[ rfz<> >ǛP\EA? r(.oM]R.M2frXS?##z[Twa3c3;끼@ПACq|,*Aa讛Qkq@~C{eYI)QAo)eR A}>m 1^?V޼C^tx츴5A}>; ڶ! Ȉ IgG*^:2 6$z^~ܱavY ar}A}F(DXT>Ol' h4y! }fkB A@'+ ١j>3^WB!}7A?H4eQ<  HEMwSNQCJ8p8Lw~>/6'75F8C_ѡPED8f>EO~'Jd&k.uED H~'  #k%RSS }UA?.H6Av< ١*s(.W~?#wQ#; BWh ɳ\ n>;^u=١ n~ʏ:I}AE,3C_A|XTOaFh`0HWDQQS.$ʅB!vpL8p8Lw~A';4A_s9r'}GW١J(b䎪XTO5F\$! P\EA? Juu5 /~6 B,*g;bn>#w^ n~(P\g(jfC]י":\(H$Bwu]`0ȢxC;f x% %;4AmOF'A ]YTOD"Fu=y+AMO9嘡(\H }塸HE`>;953~? H$<˕&axFuD#x& U`0HxFuu)Cx% %;4AMOygѨ|>YTO~ }Mȝa(D".@p8 }A?2r]"|>v< 8WEOQ W~ }ȝP(ĢxBuUu]OʅB!}W035E3 Y}7A?n~0$<F"FrK$!k f'.$ʥ~' p;AFڡOx%C}]%B *~GP.H  `;O>#w@ }A? P((2)&I$aQӠ}7A_u>3PH;`E,NWC2B!>AP~C5#wr>*@ (:3U`0Hx&C}f P\@u>#w^Fɍ}7A?D"RWWGWCu]"A_Sp(.AP($}'>E,':4A;#(DQ J p8Lwkkk١t>3I. '; ~axC? j ,*'~~۠2OvWWWH$Q QCJ$P\AτB!  *~8fQ0;Dn#< }EA_u ,*'~۠F%HXNwCPP\MfF):.>}@1 BQ#3}F(p;A}W|>#wTE(  n~4%<۠  OwG"۠D8iP\EA?}A_@`0;"zC}}gR:4AM}g~`>#w^ WCPD"Q;}m ,*'|>`A]9WS4r'Έ#_)aE} *P\)3D">D}@1OthӅ A? %;4AM|*fˤq&'?gd^xrWU^*_{?ari??/}Uz>x/u1;]xrՕWUW^*_\_pKU+uXJzɸ9Ȍ "~*.GyĹW~伯|U伯l=|j#9>GJ_*6o-ev7=G_*rco9\9_cz̈\}%&-[/; fM}A_u BE>!|wAKIII-y[эuʮrH\&MGР?>&GypG f? yy+"?rHzY ,ʋޔ=?${wmy5_S3zȿ2 zMҷ?oɸ "__93-+W~Β%W+v;,Tr7_~U)ya)1%Ȫ~-ߏ _?o>^'V?r|_Gu*Z\u9S?{>EUrWAk-$>xΕ˯sI#_.fE_;W߿ܷ*kJns|M\̚*~$I.~/ӿ^Ѽngꒌ}Z%7ۗM HAOeB QQ~:\9sܯfg#.jF|jξFDzloK?/no}/UP7Y]-]]o#׌߯Y n~8]׋:xag+֭W^v;274G2qL?ҳv6l寳<֦?n靜]?IPmJ -wݣ[s^E+}oսOUOeHrz9O{멽:۩]m,ه燭^ϧ*(/LCGd~#Ŕ5f͚ȤϹN,H:e͘.3(k"`зg=0cVUq^`%]TRVJ%%T"P Ob*SSay|,򁠢*c7B!cL }>rCI.tRW维SeKm')o- ʡŠ:z(i>O_kΥּվY47w%m+}M]Dtw UBi"ɯk3^E7sV\+IM'ަngGIP޺Nt}cv/X5[jhUVE2Q3/ZD=Q'==WO? y}}E@UQii eT^匈TISZp.eͼQ=4&XDlSDdl tZ_B_OhG/2Ix.sOD΀9)JSQq e1o7bv{h҈a64/|zU a|^ʹD:ȑV>xcBUB}uvuЋ[' FуES4Mh$м{eejpW7qz.whDKQeME/U,w=D;urM "_q=e }`gJODHq@~Ἳα92o^E-S0B1{˶YLr(K z&}ψy[-y()ʇA&炜ЉU$g X \aU{\ʢjM<>G0gB&ke)@Bį:%C_K̻`B=ژ S@ocAn.ZN?B6%OACO٦E? 5Vc> )Kt}lOgC}<=HkXBDh4#wM[ۓBM(r!c#2ޓ>H_H >)o]~1 OtE=P?ټ+Ƞ12f)BBxoI3^e&95Aoɫvw AXGQB#B}97^uAI~r\^;_feͥsinv0XEߤmgeTvѳtL+m;Kq}Gd-mܾ}{hOEn-y2ò=32aL]E3JgQzb+d$W"KNSn7;ֳ7qY:J-ki{ޔ%iuA:rZRxυ~dtmsv* =ɔ _$cpbY -0ok+Pϔt^ZO淧WH|.^zGUa~Tg҆~SYI[^sy؈L̸AP|Xgf'.,UL7b R~#TTTDEEri34f-\Jkٴim**SF#Q~QmTDkeX1sߍ\fuR ?p濖:跧@':YBnyoܗҙ3-th3=WVeO49JgϝmS9,?b8m=TZvI},t*yRBM1\= ?? ;b AH=t74> CyU)|ƳY(e "a!i__lpd>Oo]Jz?3KP㭄UzFFW,uZM.BR3^Rs贰@ޮ])}k-ڞC#Ťȇt0M`\ ;XK}KWQkyj_۳[K^K혛S.d",ToB?1% [#>!~U+4'BZLP,IECrLB_)' z/>}‡;-u,,^3#?2kSI =/ҙ3-B--'E~>8a:\L6j3 >z˟xo?Iie}vk!#-%SsZO>"/v~Z$B{Ol%2ŵYZj[ۥf~Ӷ&*nj="=[P#~jCU>@l(*(ȧb,.7]ϻ"屗xB?哗%=F]*++hUGqhyac*oPJFSTo0G{UC3C^})A'WW{]>Q9{,¾ u8٢xW1 h_[[#wTBJ1Vb_7$~1&h_DҨZsT_8VWϽE;\lVToJvT<w7$]e;~s! !SgtQjn>F>T(KwHҕTbt,\WCD?F[QT~t3OBvc(_ņ줎N>SǹYeP>*]N?/!J@ FÆ!qiͦE*JAЯ( l;e, -@BA.ma! |TFULZ_xT ֬5\Ktxx*,WKLy4_ B(VGZe+B'7-FWTX꠳gZt,]t[[lϵcG-v4.g-g85zjooN/C\ |Bcq~]]544 ξe7ot^\8cz},~ZW֕.p·us6鎞fv)Ztspd~œEWd]+xM.28~"Of*\/.x2RXm}%;b9Yޥn9e֩ֈU[oԾ5Rm`#SbqZ$M {hAz"{Kz ߜ21tU wE!eHwPEY nGI22?Q~ZS$o1RtC/ ?CoEO&z++Jhl特xĞiy(PAJCI<:-Kh׏!92Uz |:~G=ō#l }7!3|zs/M?ڱEzZ(x ѡgI?ϤEhʇ1{+K(?B?RccAy,艈_>/6qA^=c:F=nouSoqHT@.F:7NYo>Rޡs%"wfo(U7_z,ۙ2^ճ5T;ORiYvNЌz6}9^/SA&Rcz5V>uJ'-u|ly8+i1eׇ_Џ)VR 2~71ݾek)K/::?5֖>tBSsNPA,ݱVQ&+·Lq1֪lRD;rhqٔϏ^De=.>q>B?^\.XB_3tfjoX]-G\B?|F9l{3_FoLFqMMMB?1.'gJ|YZ8Psi |ϔF≐Im>ʾWs>wt]1XMq- &O^õ#RдH$bss~͡i|а#GS \-CWX.x>AD4Vm-~BaMe粔E+yA 2W_=+SzdzB1nھ^XBWReZe…f=}vXj{eg%4k,5k.;4:BQn#N0Χ濖{kXF}HModT|,*7^ڽ !~#NxX~MM[e~$Q=/IB[Bn]0`tig")KsHB`JzOZ'=ɵ\@Mbz"Ҷ1Gۿ14o"Z~Yn@.uN+/=Utò=#%9wy+A ~u[N߶K>;_/ȰƟ \\o1$JcO؜N2o(AP#2)sD:Hq4cBZ]Y-;vܲlIgJ|&З%n 8x:=XܻtƤwE菕yvA翰Χ7VPЯ;^w}`BUEu\ǹWi P^!{zb[GLj`,= "w4*E$A܏DTSS3 ʡsҎxn:Ps>"weE||a}-(\@Gr澄~e &Ӄk%WzV>͗nh^: ؓ0ƋP"p4np }tZYtkìDAs.׌r䎇c+}B_7^ս"#аVcY1Esk5|fU,M^qn<ǡh IM\󛑗C;|jT_;+} }4J<^춽۾JV|PIW:}kY [qY˶X2B?-u,b8-Axܷ?*[兮6&__O3mA{=t\4fHbd S/kT7-䩽4Ɔ\sͩ0|fT^ka/0Cdžm#3$YOc+ SIYB'clB`Ζ_K97.NsP^@uզ674ؗ"B.ﻁFV׸#wehN͘[*jM9^QB?fIB_Uf ݅WxӪݱɯD4q[y{B` }*sGxڙ]I#cv%r//QO )b%9tUKiC#M.Ԥ:BG'c:g= _[[+ { g _pkiah$W>Q2<]@د{]wȇt**/Nͥ䔥z;/HRxYT7ieU- .2!V@e0K5%ЏM2)o ,*ӼI(++Kq#%7f͓NkK25S7>jięWЗ8&u8^!gf{.'/"r*?9'B6B+B~A5V6]~4z}jHTI?m͟ƭ2Ѕ*F#ƸJ;}'] cAE %A~e }$.Viw`mTL  BoOnqR }@4(]Knu]̦J*c$ T2F=J-ͷ!joowR-]G'o? :¯_>?y:}Cӿ}w<6yAԄ֊ B?-u]j{P8x>#?\q{-oe.o:C_D$} 2IBBclcl.cl~CC"w4x dT' <>booɠ+ylU*O }Uǫ|9F~~/~vJ_I9}s> ~T7bwGx:8nRCJ/hTR󩸼ʨ*ʷi{]+c}*P%08 4'I(+ke{i&ک|<;BB~0&) o$e5uyOzAI$XOm>O}`w9 V_WW3nz%?pqпM ?ZcYЯAS\ b^/|A&=s6OՉ>hK_Ba-*|*#/8liRƋ)7mr.:wUoǫcp;zv玊+/QduxmݡkElYڙYEh?)Ϩ ̱\f{0Y>A9^ea },7 .%cvw}%׼4f/_BPݣS54P2֗6Я[8OyrNey!Mf<@C&eNF&hkDt'|.%:L:*ϤNfc=%1 zeek.G+~ o P}<m8;F)B{PUQuكJD]te;JW- uHjj4Š,Z[zui"^&̬m$gHֽ/Q{wk.bP_RѶRqA/IOuysVҹst9q]naLC?~O,njJWO^Rmn.m;K.uPW \Og}:o=/q)K8 =NqzN4G@NS4ST{4 CmTT/ͥ siu&IA*,G\ mMPIo_Z6mD%Tql,^ AoзISZ6mDۊKBccdM骸픟.]NKn_ߟu!<72+-R@s{nO;…sJ.+=х~U;Gzn)X~CCclg* =pCl7}gScE_WW+J^<w_W-N%_@MOnNs\w*5Bv|6/kjx>zfi[X'4Ó }slb_A菋%hۭtMD([Y/+ҿhUKQ-*ཬo,OR,u{0bmB?-2~Iヮ!}ހAh9x/Lߞ?뎭`q˫0oBϡ폀3i4*Dev{;k0ܡws~ @Пn8  w o B.B.cGa,cl$0F|C;_;$u?f3/SGz_g+.kvdr'u)[>59qvyNbkw¨(]DBoicฟ|x:vy7V:s8Lw9Ŗx ;.gМ:= R3ik>^KGϯ~oc/mwRŒy3W<?AKgטؽe;yHRi׹NN/LvύiѶx|;71qBDZkym IK֚NHOyE;l[9'%;I\~L#T<ۃaN9m+zfh7<Ʋ|e7qVYI;h沇y*Kh2wYPx;Ao(*J ]{jw l}viO s}^(濲|]:( ߺT[k~p>u|{{>Cwτ8oQE?p?2q; B_ oND;c{X +)){cq___ϳOjgh殣]Q˙V:w\smth%_/Bf:z.LǎcQغ6;/~c6S3T۱WQQQ篤H2)h'U5ǏǨ9ZE{JҪn%xqzйEpy|Kmg"g-g/Q ~;w/]Giw\Aΐ4kRZSmڼKĠFY;Џ2e+iҥJ|>_B'5 UO6e46}ߑBSƗ|E*HBJߍ21%dh맻|Ј]ֽnh$/+JETGA@}$Я;ق2xagNnq@.B3kW?11E򣍍18S3ohhH0_74ޮL.T(Hїߕ$B$B_``:m醫d7\vBCGb2ƾ!21Rc716 #cL46o;'~Z4L C_Lcr2p8% ƍ̡ Qu7b~_``RUU1 qzGN o+3-?Qf#~%7ƽ7ƭE# @殢y+ieJmgFy>o{w᰹пFQ:hϥJAXo B{F4Y]F7clSc܃C q':p }S ͅ7 75Yq˻ $/W; }1._7Fw_Y3i;16!"kkkyR W5i8a ¿iq.ņNB_MnB.v $ycܯ\-4U777#r@hB?RSS9w4B 7BA,}'%91Jˍqi{_yk Fzϟ& qUB77Í IBUqF6Qclӧ=E^7x,QiU)?_ REJvqoh;L9l{(577cPfF$L2\5OwϗWr ZA5U9cl)iSNaPSNсLdq;.bMMi}h|=w=cKq hhhFٞq~Pmڞjhh."||?8q?8qa:u D'O$#ng3R#m)|m1(uryNb;cO>M:>|^x7x^~%ML555='OFI7MMM;ē*.{\SSC=+xZ|t<_q.@qdA?8q?8q_W^y?^Ç믿NO&:ëŸ1?v|׷mѿCcw+{2ebe3g111S2Xcl5cAZ:Xclc111111V{1V+ed1ƞd1VePa۠)mx vTܣr=+冋}p; Wp.wv7w~7.x4\qjE[pͳ l wŸ%?KC\OB_1}916161611X]~e=bAs%(E/ ;* Iq iK?B pE/db)3l9O| W7no~nC\OB߭1S]NDҟntag-4vOlC|zÌGj}Qos_B ]ϩrOJL𬥂UIm1z?d#b8䅆S1L9O3*;_ۉ0X*~qubwcy[Tqc0(Ub?٩ )*'*{SQܗqȗ.x̷qq;:u#1w,}U>ݹx9]#RB/dQ<,\wb$ :SC-V{Q_EX/e /Q;b3X[Η5vGnkW?1n4#w<}YꋍrW0VYXQ/ ~Ys/~Q(~VI܋^r5ÒWx37e/FL2IrW5vļ&}QBf#7UUnt ɬ;<}QϗRXo,y:_h Ys/~.eVL#}L*"_\ge|I拹S ,G4]r3ܯ1oq;dN~E{ r3FE/f/`-b;T,_ſ I/-}[7((y5"Gnx3g2_ϣvFިaVU4U|ڡ:-?GJ?b<bosG.Zj8l|fNq;hPBߩJffשJ6[/G e7^kE?Ac2s֗>Y+\?( YX ''*Sѭ>`#_KYo,3. ?p?4ܴëosηk{Kuo7vGҿC*z bԟnt"b^/}ųHKl(e?"mx)v^T+%i'傗A/b:ȗ1W%!VEV;5;nqT;\EꋍrWUb~֛FK~.Eυ bEeL?RI$֛B䫪E:|17_ډ:߮B?*}'ϣw̿p/Gģ:ߗwRf[/6;<}7"H}1Gַc$?F_}$GׇU^*?AcDX/Fp!UbԎW2_:?&k]􎜧bAƆ#xx>֗>t%ϒ47@CU.Ut"{Q;ILfE>UbN`1;\˹:Q;~]~,U;/Rvc"xl}QgђW ~.e/~QLd*tSe:Q! V"_#v0Wς׉ډ:_Kҷ*ilی #xj}ؿYmX%?c%/JY19nT$a?Vc_#{_./W mIrNJ_7zǮI,floPUbN?cy%(Ŋ~Q_X`89SٯHŽ(G >7]Q/K;mDX/pb\Q;5Չډ:_[VJ[$/VY!Z_%#(*~ɰ!IȾUr(u%~AUE(Ej#H;U9,[Q!,K|" !XMB?ѤW&WUˢ_xqv{ ip $DSS\FnNb_,$w$ٯvt8R;*{Y٪,E/W;||MpD8 }UAH}Qs+,$(e/λ~[.^N_W䫪Ð^B?^R-G֗ž#Vso'U_w0@*+{o8{$c1ZG:UbN_|B-O_'S_ZIU˕*%,Eu 7lDmWI|_W;Uf,Ôs:b߮y,U_%U_2 ʏׯH{;y/ |Y5N2cqB?R_#V}Y; ~Qۉ/;Hh<, "Ur*/K|]w؉wH", timeout=5) context.cli.sendcontrol("c") context.cli.sendcontrol("d") context.cli.expect_exact(pexpect.EOF, timeout=5) if os.path.exists(MY_CNF_BACKUP_PATH): shutil.move(MY_CNF_BACKUP_PATH, MY_CNF_PATH) if os.path.exists(MYLOGIN_CNF_BACKUP_PATH): shutil.move(MYLOGIN_CNF_BACKUP_PATH, MYLOGIN_CNF_PATH) elif os.path.exists(MYLOGIN_CNF_PATH): # This file was moved in `before_scenario`. # If it exists now, it has been created during a test os.remove(MYLOGIN_CNF_PATH) # TODO: uncomment to debug a failure # def after_step(context, step): # if step.status == "failed": # import ipdb; ipdb.set_trace() ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1762004092.2968173 mycli-1.41.0/test/features/fixture_data/0000755000175100017510000000000015101406174017633 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/features/fixture_data/help.txt0000644000175100017510000000347015101406164021327 0ustar00runnerrunner+--------------------------+-----------------------------------------------+ | Command | Description | |--------------------------+-----------------------------------------------| | \# | Refresh auto-completions. | | \? | Show Help. | | \c[onnect] database_name | Change to a new database. | | \d [pattern] | List or describe tables, views and sequences. | | \dT[S+] [pattern] | List data types | | \df[+] [pattern] | List functions. | | \di[+] [pattern] | List indexes. | | \dn[+] [pattern] | List schemas. | | \ds[+] [pattern] | List sequences. | | \dt[+] [pattern] | List tables. | | \du[+] [pattern] | List roles. | | \dv[+] [pattern] | List views. | | \e [file] | Edit the query with external editor. | | \l | List databases. | | \n[+] [name] | List or execute named queries. | | \nd [name [query]] | Delete a named query. | | \ns name query | Save a named query. | | \refresh | Refresh auto-completions. | | \timing | Toggle timing of commands. | | \x | Toggle expanded output. | +--------------------------+-----------------------------------------------+ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/features/fixture_data/help_commands.txt0000644000175100017510000000723415101406164023212 0ustar00runnerrunner+----------------+----------------------------+------------------------------------------------------------+ | Command | Shortcut | Description | +----------------+----------------------------+------------------------------------------------------------+ | \G | \G | Display current query results vertically. | | \clip | \clip | Copy query to the system clipboard. | | \dt | \dt[+] [table] | List or describe tables. | | \e | \e | Edit command with editor (uses $EDITOR). | | \f | \f [name [args..]] | List or execute favorite queries. | | \fd | \fd [name] | Delete a favorite query. | | \fs | \fs name query | Save a favorite query. | | \l | \l | List databases. | | \llm | \ai | Interrogate LLM. | | \once | \o [-o] filename | Append next result to an output file (overwrite using -o). | | \pipe_once | \| command | Send next result to a subprocess. | | \timing | \t | Toggle timing of commands. | | connect | \r | Reconnect to the database. Optional database argument. | | delimiter | | Change SQL delimiter. | | exit | \q | Exit. | | help | \? | Show this help. | | nopager | \n | Disable pager, print to stdout. | | notee | notee | Stop writing results to an output file. | | pager | \P [command] | Set PAGER. Print the query results via PAGER. | | prompt | \R | Change prompt format. | | quit | \q | Quit. | | redirectformat | \Tr | Change the table format used to output redirected results. | | rehash | \# | Refresh auto-completions. | | source | \. filename | Execute commands from file. | | status | \s | Get status information from the server. | | system | system [command] | Execute a system shell commmand. | | tableformat | \T | Change the table format used to output results. | | tee | tee [-o] filename | Append all results to an output file (overwrite using -o). | | use | \u | Change to a new database. | | watch | watch [seconds] [-c] query | Executes the query every [seconds] seconds (by default 5). | +----------------+----------------------------+------------------------------------------------------------+ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/features/fixture_utils.py0000644000175100017510000000131515101406164020433 0ustar00runnerrunner# type: ignore import os def read_fixture_lines(filename): """Read lines of text from file. :param filename: string name :return: list of strings """ lines = [] for line in open(filename): lines.append(line.strip()) return lines def read_fixture_files(): """Read all files inside fixture_data directory.""" fixture_dict = {} current_dir = os.path.dirname(__file__) fixture_dir = os.path.join(current_dir, "fixture_data/") for filename in os.listdir(fixture_dir): if filename not in [".", ".."]: fullname = os.path.join(fixture_dir, filename) fixture_dict[filename] = read_fixture_lines(fullname) return fixture_dict ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/features/iocommands.feature0000644000175100017510000000716415101406164020671 0ustar00runnerrunnerFeature: I/O commands Scenario: edit sql in file with external editor When we start external editor providing a file name and we type "select * from abc" in the editor and we exit the editor then we see dbcli prompt and we see "select * from abc" in prompt Scenario: tee output from query When we tee output and we wait for prompt and we select "select 123456" and we wait for prompt and we notee output and we wait for prompt then we see 123456 in tee output Scenario: set delimiter When we query "delimiter $" then delimiter is set to "$" Scenario: set delimiter twice When we query "delimiter $" and we query "delimiter ]]" then delimiter is set to "]]" Scenario: set delimiter and query on same line When we query "select 123; delimiter $ select 456 $ delimiter %" then we see tabular result "123" and we see tabular result "456" and delimiter is set to "%" Scenario: send output to file When we query "\o /tmp/output1.sql" and we query "select 123" and we query "system cat /tmp/output1.sql" then we see csv result "123" Scenario: send output to file two times When we query "\o /tmp/output1.sql" and we query "select 123" and we query "\o /tmp/output2.sql" and we query "select 456" and we query "system cat /tmp/output2.sql" then we see csv result "456" Scenario: shell style redirect to file When we query "select 123 as constant $> /tmp/output1.csv" and we query "system cat /tmp/output1.csv" then we see csv 123 in file output Scenario: shell style redirect to command When we query "select 100 $| wc" then we see space 12 in command output Scenario: shell style redirect to multiple commands When we query "select 100 $| head -1 $| wc" then we see space 6 in command output Scenario: shell style redirect to multiple commands with minimal spaces When we query "select 100$|head -1$|wc" then we see space 6 in command output Scenario: shell style redirect to multiple commands containing single quotes When we query "select 100 $| head '-1' $| wc" then we see space 6 in command output Scenario: shell style redirect to multiple commands containing single quotes and minimal spaces When we query "select 100$|head '-1'$|wc" then we see space 6 in command output Scenario: shell style redirect to multiple commands containing mixed quoted and unquoted arg When we query "select 100 $| head -'1' $| wc" then we see space 6 in command output Scenario: shell style redirect to multiple commands containing double quotes When we query "select 100 $| head ""-1"" $| wc" then we see space 6 in command output Scenario: shell style redirect with commands and capture to file When we query "select 100 $| head -1 $| wc $> /tmp/output1.txt" and we query "system cat /tmp/output1.txt" then we see text 6 in file output Scenario: shell style redirect with append to file When we query "select 100 $> /tmp/output1.csv" and we query "select 200 $>> /tmp/output1.csv" and we query "system cat /tmp/output1.csv" then we see csv 100 in file output and we see csv 200 in file output Scenario: shell style redirect with command and append to file When we query "select 300 $| grep 0 $> /tmp/output1.csv" and we query "select 400 $| grep 0 $>> /tmp/output1.csv" and we query "system cat /tmp/output1.csv" then we see csv 300 in file output and we see csv 400 in file output ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/features/named_queries.feature0000644000175100017510000000175715101406164021363 0ustar00runnerrunnerFeature: named queries: save, use and delete named queries Scenario: save, use and delete named queries When we connect to test database then we see database connected when we save a named query then we see the named query saved when we use a named query then we see the named query executed when we delete a named query then we see the named query deleted Scenario: save, use and delete named queries with parameters When we connect to test database then we see database connected when we save a named query with parameters then we see the named query saved when we use named query with parameters then we see the named query with parameters executed when we use named query with too few parameters then we see the named query with parameters fail with missing parameters when we use named query with too many parameters then we see the named query with parameters fail with extra parameters ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/features/specials.feature0000644000175100017510000000025615101406164020336 0ustar00runnerrunnerFeature: Special commands @wip Scenario: run refresh command When we refresh completions and we wait for prompt then we see completions refresh started ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1762004092.2988172 mycli-1.41.0/test/features/steps/0000755000175100017510000000000015101406174016312 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/features/steps/__init__.py0000644000175100017510000000000015101406164020410 0ustar00runnerrunner././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/features/steps/auto_vertical.py0000644000175100017510000000260415101406164021526 0ustar00runnerrunner# type: ignore from textwrap import dedent from behave import then, when from utils import parse_cli_args_to_dict import wrappers @when("we run dbcli with {arg}") def step_run_cli_with_arg(context, arg): wrappers.run_cli(context, run_args=parse_cli_args_to_dict(arg)) @when("we execute a small query") def step_execute_small_query(context): context.cli.sendline("select 1") @when("we execute a large query") def step_execute_large_query(context): context.cli.sendline(f"select {','.join([str(n) for n in range(1, 50)])}") @then("we see small results in horizontal format") def step_see_small_results(context): expected = ( dedent( """ +---+\r | 1 |\r +---+\r | 1 |\r +---+ """ ).strip() + '\r\n\r\n' ) wrappers.expect_pager( context, expected, timeout=5, ) wrappers.expect_exact(context, "1 row in set", timeout=2) @then("we see large results in vertical format") def step_see_large_results(context): rows = [f"{str(n):3}| {n}" for n in range(1, 50)] delimited_rows = '\r\n'.join(rows) + '\r\n' expected = "***************************[ 1. row ]***************************\r\n" + delimited_rows + "\r\n" wrappers.expect_pager(context, expected, timeout=10) wrappers.expect_exact(context, "1 row in set", timeout=2) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/features/steps/basic_commands.py0000644000175100017510000000764715101406164021643 0ustar00runnerrunner# type: ignore """Steps for behavioral style tests are defined in this module. Each step is defined by the string decorating it. This string is used to call the step in "*.feature" file. """ import datetime import tempfile from textwrap import dedent from behave import then, when import wrappers @when("we run dbcli") def step_run_cli(context): wrappers.run_cli(context) @when("we wait for prompt") def step_wait_prompt(context): wrappers.wait_prompt(context) @when('we send "ctrl + d"') def step_ctrl_d(context): """Send Ctrl + D to hopefully exit.""" context.cli.sendcontrol("d") context.exit_sent = True @when('we send "ctrl + o, ctrl + d"') def step_ctrl_o_ctrl_d(context): """Send ctrl + o, ctrl + d to insert the quoted date.""" context.cli.send("SELECT ") context.cli.sendcontrol("o") context.cli.sendcontrol("d") context.cli.send(" AS dt") context.cli.sendline("") @when(r'we send "\?" command') def step_send_help(context): r"""Send \? to see help. """ context.cli.sendline("\\?") wrappers.expect_exact(context, context.conf["pager_boundary"] + "\r\n", timeout=5) @when("we send source command") def step_send_source_command(context): with tempfile.NamedTemporaryFile() as f: f.write(b"\\?") f.flush() context.cli.sendline(f"\\. {f.name}") wrappers.expect_exact(context, context.conf["pager_boundary"] + "\r\n", timeout=5) @when("we run query to check application_name") def step_check_application_name(context): context.cli.sendline( "SELECT 'found' FROM performance_schema.session_connect_attrs WHERE attr_name = 'program_name' AND attr_value = 'mycli'" ) @then("we see found") def step_see_found(context): expected = ( dedent( """ +-------+\r | found |\r +-------+\r | found |\r +-------+ """ ).strip() + '\r\n\r\n' ) wrappers.expect_exact( context, context.conf["pager_boundary"] + '\r\n' + expected + context.conf["pager_boundary"], timeout=5, ) @then("we see the date") def step_see_date(context): # There are some edge cases in which this test could fail, # such as running near midnight when the test database has # a different TZ setting than the system. date_str = datetime.datetime.now().strftime("%Y-%m-%d") expected = ( dedent( f""" +------------+\r | dt |\r +------------+\r | {date_str} |\r +------------+ """ ).strip() + '\r\n\r\n' ) wrappers.expect_exact( context, context.conf["pager_boundary"] + '\r\n' + expected + context.conf["pager_boundary"], timeout=5, ) @then("we confirm the destructive warning") def step_confirm_destructive_command(context): # noqa """Confirm destructive command.""" wrappers.expect_exact(context, "You're about to run a destructive command.\r\nDo you want to proceed? (y/n):", timeout=2) context.cli.sendline("y") @when('we answer the destructive warning with "{confirmation}"') def step_confirm_destructive_command(context, confirmation): # noqa """Confirm destructive command.""" wrappers.expect_exact(context, "You're about to run a destructive command.\r\nDo you want to proceed? (y/n):", timeout=2) context.cli.sendline(confirmation) @then('we answer the destructive warning with invalid "{confirmation}" and see text "{text}"') def step_confirm_destructive_command(context, confirmation, text): # noqa """Confirm destructive command.""" wrappers.expect_exact(context, "You're about to run a destructive command.\r\nDo you want to proceed? (y/n):", timeout=2) context.cli.sendline(confirmation) wrappers.expect_exact(context, text, timeout=2) # we must exit the Click loop, or the feature will hang context.cli.sendline("n") ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/features/steps/connection.py0000644000175100017510000000357315101406164021032 0ustar00runnerrunner# type: ignore import io import os from behave import then, when import wrappers from mycli.config import encrypt_mylogin_cnf from test.features.environment import MY_CNF_PATH, MYLOGIN_CNF_PATH, get_db_name_from_context from test.features.steps.utils import parse_cli_args_to_dict from test.utils import HOST, PASSWORD, PORT, USER TEST_LOGIN_PATH = "test_login_path" @when('we run mycli with arguments "{exact_args}" without arguments "{excluded_args}"') @when('we run mycli without arguments "{excluded_args}"') def step_run_cli_without_args(context, excluded_args, exact_args=""): wrappers.run_cli(context, run_args=parse_cli_args_to_dict(exact_args), exclude_args=parse_cli_args_to_dict(excluded_args).keys()) @then('status contains "{expression}"') def status_contains(context, expression): wrappers.expect_exact(context, f"{expression}", timeout=5) # Normally, the shutdown after scenario waits for the prompt. # But we may have changed the prompt, depending on parameters, # so let's wait for its last character context.cli.expect_exact(">") context.atprompt = True @when("we create my.cnf file") def step_create_my_cnf_file(context): my_cnf = f"[client]\nhost = {HOST}\nport = {PORT}\nuser = {USER}\npassword = {PASSWORD}\n" with open(MY_CNF_PATH, "w") as f: f.write(my_cnf) @when("we create mylogin.cnf file") def step_create_mylogin_cnf_file(context): os.environ.pop("MYSQL_TEST_LOGIN_FILE", None) mylogin_cnf = f"[{TEST_LOGIN_PATH}]\nhost = {HOST}\nport = {PORT}\nuser = {USER}\npassword = {PASSWORD}\n" with open(MYLOGIN_CNF_PATH, "wb") as f: input_file = io.StringIO(mylogin_cnf) f.write(encrypt_mylogin_cnf(input_file).read()) @then("we are logged in") def we_are_logged_in(context): db_name = get_db_name_from_context(context) context.cli.expect_exact(f"{db_name}>", timeout=5) context.atprompt = True ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/features/steps/crud_database.py0000644000175100017510000000637615101406164021460 0ustar00runnerrunner# type: ignore """Steps for behavioral style tests are defined in this module. Each step is defined by the string decorating it. This string is used to call the step in "*.feature" file. """ from behave import then, when import pexpect import wrappers @when("we create database") def step_db_create(context): """Send create database.""" context.cli.sendline(f"create database {context.conf['dbname_tmp']};") context.response = {"database_name": context.conf["dbname_tmp"]} @when("we drop database") def step_db_drop(context): """Send drop database.""" context.cli.sendline(f"drop database {context.conf['dbname_tmp']};") @when("we connect to test database") def step_db_connect_test(context): """Send connect to database.""" db_name = context.conf["dbname"] context.currentdb = db_name context.cli.sendline(f"use {db_name};") @when("we connect to quoted test database") def step_db_connect_quoted_tmp(context): """Send connect to database.""" db_name = context.conf["dbname"] context.currentdb = db_name context.cli.sendline(f"use `{db_name}`;") @when("we connect to tmp database") def step_db_connect_tmp(context): """Send connect to database.""" db_name = context.conf["dbname_tmp"] context.currentdb = db_name context.cli.sendline(f"use {db_name}") @when("we connect to dbserver") def step_db_connect_dbserver(context): """Send connect to database.""" context.currentdb = "mysql" context.cli.sendline("use mysql") @then("dbcli exits") def step_wait_exit(context): """Make sure the cli exits.""" wrappers.expect_exact(context, pexpect.EOF, timeout=5) @then("we see dbcli prompt") def step_see_prompt(context): """Wait to see the prompt.""" user = context.conf["user"] host = context.conf["host"] dbname = context.currentdb wrappers.wait_prompt(context, f"{user}@{host}:{dbname}> ") @then("we see help output") def step_see_help(context): for expected_line in context.fixture_data["help_commands.txt"]: # in case tests are run without extras if 'LLM' in expected_line: continue wrappers.expect_exact(context, expected_line, timeout=1) @then("we see database created") def step_see_db_created(context): """Wait to see create database output.""" wrappers.expect_exact(context, "Query OK, 1 row affected", timeout=2) @then("we see database dropped") def step_see_db_dropped(context): """Wait to see drop database output.""" wrappers.expect_exact(context, "Query OK, 0 rows affected", timeout=2) @then("we see database dropped and no default database") def step_see_db_dropped_no_default(context): """Wait to see drop database output.""" user = context.conf["user"] host = context.conf["host"] database = "(none)" context.currentdb = None wrappers.expect_exact(context, "Query OK, 0 rows affected", timeout=2) wrappers.wait_prompt(context, f"{user}@{host}:{database}>") @then("we see database connected") def step_see_db_connected(context): """Wait to see drop database output.""" wrappers.expect_exact(context, 'You are now connected to database "', timeout=2) wrappers.expect_exact(context, '"', timeout=2) wrappers.expect_exact(context, f' as user "{context.conf["user"]}"', timeout=2) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/features/steps/crud_table.py0000644000175100017510000000615215101406164020773 0ustar00runnerrunner# type: ignore """Steps for behavioral style tests are defined in this module. Each step is defined by the string decorating it. This string is used to call the step in "*.feature" file. """ from textwrap import dedent from behave import then, when import wrappers @when("we create table") def step_create_table(context): """Send create table.""" context.cli.sendline("create table a(x text);") @when("we insert into table") def step_insert_into_table(context): """Send insert into table.""" context.cli.sendline("""insert into a(x) values('xxx');""") @when("we update table") def step_update_table(context): """Send insert into table.""" context.cli.sendline("""update a set x = 'yyy' where x = 'xxx';""") @when("we select from table") def step_select_from_table(context): """Send select from table.""" context.cli.sendline("select * from a;") @when("we delete from table") def step_delete_from_table(context): """Send deete from table.""" context.cli.sendline("""delete from a where x = 'yyy';""") @when("we drop table") def step_drop_table(context): """Send drop table.""" context.cli.sendline("drop table a;") @then("we see table created") def step_see_table_created(context): """Wait to see create table output.""" wrappers.expect_exact(context, "Query OK, 0 rows affected", timeout=2) @then("we see record inserted") def step_see_record_inserted(context): """Wait to see insert output.""" wrappers.expect_exact(context, "Query OK, 1 row affected", timeout=2) @then("we see record updated") def step_see_record_updated(context): """Wait to see update output.""" wrappers.expect_exact(context, "Query OK, 1 row affected", timeout=2) @then("we see data selected") def step_see_data_selected(context): """Wait to see select output.""" expected = ( dedent( """ +-----+\r | x |\r +-----+\r | yyy |\r +-----+ """ ).strip() + '\r\n\r\n' ) wrappers.expect_pager( context, expected, timeout=2, ) wrappers.expect_exact(context, "1 row in set", timeout=2) @then("we see record deleted") def step_see_data_deleted(context): """Wait to see delete output.""" wrappers.expect_exact(context, "Query OK, 1 row affected", timeout=2) @then("we see table dropped") def step_see_table_dropped(context): """Wait to see drop output.""" wrappers.expect_exact(context, "Query OK, 0 rows affected", timeout=2) @when("we select null") def step_select_null(context): """Send select null.""" context.cli.sendline("select null;") @then("we see null selected") def step_see_null_selected(context): """Wait to see null output.""" expected = ( dedent( """ +--------+\r | NULL |\r +--------+\r | |\r +--------+ """ ).strip() + '\r\n\r\n' ) wrappers.expect_pager( context, expected, timeout=2, ) wrappers.expect_exact(context, "1 row in set", timeout=2) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/features/steps/iocommands.py0000644000175100017510000000773015101406164021023 0ustar00runnerrunner# type: ignore import os from textwrap import dedent from behave import then, when import wrappers @when("we start external editor providing a file name") def step_edit_file(context): """Edit file with external editor.""" context.editor_file_name = os.path.join(context.package_root, f"test_file_{context.conf['vi']}.sql") if os.path.exists(context.editor_file_name): os.remove(context.editor_file_name) context.cli.sendline(f"\\e {os.path.basename(context.editor_file_name)}") wrappers.expect_exact(context, 'Entering Ex mode. Type "visual" to go to Normal mode.', timeout=4) wrappers.expect_exact(context, "\r\n:", timeout=4) @when('we type "{query}" in the editor') def step_edit_type_sql(context, query): context.cli.sendline("i") context.cli.sendline(query) context.cli.sendline(".") wrappers.expect_exact(context, "\r\n:", timeout=4) @when("we exit the editor") def step_edit_quit(context): context.cli.sendline("x") wrappers.expect_exact(context, "written", timeout=4) @then('we see "{query}" in prompt') def step_edit_done_sql(context, query): for match in query.split(" "): wrappers.expect_exact(context, match, timeout=5) # Cleanup the command line. context.cli.sendcontrol("c") # Cleanup the edited file. if context.editor_file_name and os.path.exists(context.editor_file_name): os.remove(context.editor_file_name) @when("we tee output") def step_tee_ouptut(context): context.tee_file_name = os.path.join(context.package_root, f"tee_file_{context.conf['vi']}.sql") if os.path.exists(context.tee_file_name): os.remove(context.tee_file_name) context.cli.sendline(f"tee {os.path.basename(context.tee_file_name)}") @when('we select "select {param}"') def step_query_select_number(context, param): context.cli.sendline(f"select {param}") expected = ( dedent( f""" +{'-' * (len(param) + 2)}+\r | {param} |\r +{'-' * (len(param) + 2)}+\r | {param} |\r +{'-' * (len(param) + 2)}+ """ ).strip() + '\r\n\r\n' ) wrappers.expect_pager( context, expected, timeout=5, ) wrappers.expect_exact(context, "1 row in set", timeout=2) @then('we see tabular result "{result}"') def step_see_tabular_result(context, result): wrappers.expect_exact(context, f'| {result} |', timeout=2) @then('we see csv result "{result}"') def step_see_csv_result(context, result): wrappers.expect_exact(context, f'"{result}"', timeout=2) @when('we query "{query}"') def step_query(context, query): context.cli.sendline(query) @when("we notee output") def step_notee_output(context): context.cli.sendline("notee") @then("we see 123456 in tee output") def step_see_123456_in_ouput(context): with open(context.tee_file_name) as f: assert "123456" in f.read() if os.path.exists(context.tee_file_name): os.remove(context.tee_file_name) @then('we see csv {result} in file output') def step_see_csv_result_in_redirected_ouput(context, result): wrappers.expect_exact(context, f'"{result}"', timeout=2) temp_filename = "/tmp/output1.csv" if os.path.exists(temp_filename): os.remove(temp_filename) @then('we see text {result} in file output') def step_see_text_result_in_redirected_ouput(context, result): wrappers.expect_exact(context, f' {result}', timeout=2) temp_filename = "/tmp/output1.txt" if os.path.exists(temp_filename): os.remove(temp_filename) @then("we see space 12 in command output") def step_see_space_12_in_command_ouput(context): wrappers.expect_exact(context, ' 12', timeout=2) @then("we see space 6 in command output") def step_see_space_6_in_command_ouput(context): wrappers.expect_exact(context, ' 6', timeout=2) @then('delimiter is set to "{delimiter}"') def delimiter_is_set(context, delimiter): wrappers.expect_exact(context, f"Changed delimiter to {delimiter}", timeout=2) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/features/steps/named_queries.py0000644000175100017510000000546115101406164021512 0ustar00runnerrunner# type: ignore """Steps for behavioral style tests are defined in this module. Each step is defined by the string decorating it. This string is used to call the step in "*.feature" file. """ from behave import then, when import wrappers @when("we save a named query") def step_save_named_query(context): """Send \fs command.""" context.cli.sendline("\\fs foo SELECT 12345") @when("we use a named query") def step_use_named_query(context): """Send \f command.""" context.cli.sendline("\\f foo") @when("we delete a named query") def step_delete_named_query(context): """Send \fd command.""" context.cli.sendline("\\fd foo") @then("we see the named query saved") def step_see_named_query_saved(context): """Wait to see query saved.""" wrappers.expect_exact(context, "Saved.", timeout=2) @then("we see the named query executed") def step_see_named_query_executed(context): """Wait to see select output.""" wrappers.expect_exact(context, "SELECT 12345", timeout=2) @then("we see the named query deleted") def step_see_named_query_deleted(context): """Wait to see query deleted.""" wrappers.expect_exact(context, "foo: Deleted", timeout=2) @when("we save a named query with parameters") def step_save_named_query_with_parameters(context): """Send \fs command for query with parameters.""" context.cli.sendline('\\fs foo_args SELECT $1, "$2", "$3"') @when("we use named query with parameters") def step_use_named_query_with_parameters(context): """Send \f command with parameters.""" context.cli.sendline('\\f foo_args 101 second "third value"') @then("we see the named query with parameters executed") def step_see_named_query_with_parameters_executed(context): """Wait to see select output.""" wrappers.expect_exact(context, 'SELECT 101, "second", "third value"', timeout=2) @when("we use named query with too few parameters") def step_use_named_query_with_too_few_parameters(context): """Send \f command with missing parameters.""" context.cli.sendline("\\f foo_args 101") @then("we see the named query with parameters fail with missing parameters") def step_see_named_query_with_parameters_fail_with_missing_parameters(context): """Wait to see select output.""" wrappers.expect_exact(context, "missing substitution for $2 in query:", timeout=2) @when("we use named query with too many parameters") def step_use_named_query_with_too_many_parameters(context): """Send \f command with extra parameters.""" context.cli.sendline("\\f foo_args 101 102 103 104") @then("we see the named query with parameters fail with extra parameters") def step_see_named_query_with_parameters_fail_with_extra_parameters(context): """Wait to see select output.""" wrappers.expect_exact(context, "query does not have substitution parameter $4:", timeout=2) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/features/steps/specials.py0000644000175100017510000000137415101406164020473 0ustar00runnerrunner# type: ignore """Steps for behavioral style tests are defined in this module. Each step is defined by the string decorating it. This string is used to call the step in "*.feature" file. """ from behave import then, when import wrappers @when("we refresh completions") def step_refresh_completions(context): """Send refresh command.""" context.cli.sendline("rehash") @then('we see text "{text}"') def step_see_text(context, text): """Wait to see given text message.""" wrappers.expect_exact(context, text, timeout=2) @then("we see completions refresh started") def step_see_refresh_started(context): """Wait to see refresh output.""" wrappers.expect_exact(context, "Auto-completion refresh started in the background.", timeout=2) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/features/steps/utils.py0000644000175100017510000000045215101406164020024 0ustar00runnerrunner# type: ignore import shlex def parse_cli_args_to_dict(cli_args: str): args_dict = {} for arg in shlex.split(cli_args): if "=" in arg: key, value = arg.split("=") args_dict[key] = value else: args_dict[arg] = None return args_dict ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/features/steps/wrappers.py0000644000175100017510000000613515101406164020533 0ustar00runnerrunner# type: ignore from io import StringIO import re import sys import textwrap import pexpect def expect_exact(context, expected, timeout): timedout = False try: context.cli.expect_exact(expected, timeout=timeout) except pexpect.TIMEOUT: timedout = True if timedout: # Strip color codes out of the output. actual = re.sub(r"\x1b\[([0-9A-Za-z;?])+[m|K]?", "", context.cli.before) raise Exception( textwrap.dedent( f"""\ Expected: --- {expected!r} --- Actual: --- {actual!r} --- Full log: --- {context.logfile.getvalue()!r} --- """ ) ) def expect_pager(context, expected, timeout): expect_exact(context, f"{context.conf['pager_boundary']}\r\n{expected}{context.conf['pager_boundary']}\r\n", timeout=timeout) def run_cli(context, run_args=None, exclude_args=None): """Run the process using pexpect.""" run_args = run_args or {} rendered_args = [] exclude_args = set(exclude_args) if exclude_args else set() conf = dict(**context.conf) conf.update(run_args) def add_arg(name, key, value): if name not in exclude_args: if value is not None: rendered_args.extend((key, value)) else: rendered_args.append(key) if conf.get("host", None): add_arg("host", "-h", conf["host"]) if conf.get("user", None): add_arg("user", "-u", conf["user"]) if conf.get("pass", None): add_arg("pass", "-p", conf["pass"]) if conf.get("port", None): add_arg("port", "-P", str(conf["port"])) if conf.get("dbname", None): add_arg("dbname", "-D", conf["dbname"]) if conf.get("defaults-file", None): add_arg("defaults_file", "--defaults-file", conf["defaults-file"]) if conf.get("myclirc", None): add_arg("myclirc", "--myclirc", conf["myclirc"]) if conf.get("login_path"): add_arg("login_path", "--login-path", conf["login_path"]) for arg_name, arg_value in conf.items(): if arg_name.startswith("-"): add_arg(arg_name, arg_name, arg_value) try: cli_cmd = context.conf["cli_command"] except KeyError: cli_cmd = f'{sys.executable} -c "import coverage ; coverage.process_startup(); import mycli.main; mycli.main.cli()"' cmd_parts = [cli_cmd] + rendered_args cmd = " ".join(cmd_parts) context.cli = pexpect.spawnu(cmd, cwd=context.package_root) context.logfile = StringIO() context.cli.logfile = context.logfile context.exit_sent = False context.currentdb = context.conf["dbname"] def wait_prompt(context, prompt=None): """Make sure prompt is displayed.""" if prompt is None: user = context.conf["user"] host = context.conf["host"] dbname = context.currentdb prompt = (f"{user}@{host}:{dbname}>",) expect_exact(context, prompt, timeout=5) context.atprompt = True ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/features/wrappager.py0000755000175100017510000000043615101406164017523 0ustar00runnerrunner#!/usr/bin/env python import sys def wrappager(boundary: str) -> None: print(boundary) while 1: buf = sys.stdin.read(2048) if not buf: break sys.stdout.write(buf) print(boundary) if __name__ == "__main__": wrappager(sys.argv[1]) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/myclirc0000644000175100017510000001426615101406164014733 0ustar00runnerrunner# vi: ft=dosini [main] # Enables context sensitive auto-completion. If this is disabled the all # possible completions will be listed. smart_completion = True # Multi-line mode allows breaking up the sql statements into multiple lines. If # this is set to True, then the end of the statements must have a semi-colon. # If this is set to False then sql statements can't be split into multiple # lines. End of line (return) is considered as the end of the statement. multi_line = False # Destructive warning mode will alert you before executing a sql statement # that may cause harm to the database such as "drop table", "drop database" # or "shutdown". destructive_warning = True # log_file location. log_file = ~/.mycli.test.log # Default log level. Possible values: "CRITICAL", "ERROR", "WARNING", "INFO" # and "DEBUG". "NONE" disables logging. log_level = DEBUG # Log every query and its results to a file. Enable this by uncommenting the # line below. # audit_log = ~/.mycli-audit.log # Timing of sql statements and table rendering. timing = True # Beep after long-running queries are completed; 0 to disable. beep_after_seconds = 0 # Table format. Possible values: ascii, double, github, # psql, plain, simple, grid, fancy_grid, pipe, orgtbl, rst, mediawiki, html, # latex, latex_booktabs, textile, moinmoin, jira, vertical, tsv, tsv_noheader, # csv, csv-noheader, jsonl, jsonl_unescaped. # Recommended: ascii table_format = ascii # Redirected otuput format # Recommended: csv. redirect_format = csv # A command to run after a successful output redirect, with {} to be replaced # with the escaped filename. Mac example: echo {} | pbcopy. Escaping is not # reliable/safe on Windows. post_redirect_command = "" # Syntax coloring style. Possible values (many support the "-dark" suffix): # manni, igor, xcode, vim, autumn, vs, rrt, native, perldoc, borland, tango, emacs, # friendly, monokai, paraiso, colorful, murphy, bw, pastie, paraiso, trac, default, # fruity. # Screenshots at http://mycli.net/syntax # Can be further modified in [colors] syntax_style = default # Keybindings: Possible values: emacs, vi. # Emacs mode: Ctrl-A is home, Ctrl-E is end. All emacs keybindings are available in the REPL. # When Vi mode is enabled you can use modal editing features offered by Vi in the REPL. key_bindings = emacs # Enabling this option will show the suggestions in a wider menu. Thus more items are suggested. wider_completion_menu = False # MySQL prompt # \D - The full current date # \d - Database name # \h - Hostname of the server # \m - Minutes of the current time # \n - Newline # \P - AM/PM # \p - Port # \R - The current time, in 24-hour military time (0-23) # \r - The current time, standard 12-hour time (1-12) # \s - Seconds of the current time # \t - Product type (Percona, MySQL, MariaDB, TiDB) # \A - DSN alias name (from the [alias_dsn] section) # \u - Username # \x1b[...m - insert ANSI escape sequence prompt = "\t \u@\h:\d> " prompt_continuation = -> # Skip intro info on startup and outro info on exit less_chatty = True # Use alias from --login-path instead of host name in prompt login_path_as_host = False # Cause result sets to be displayed vertically if they are too wide for the current window, # and using normal tabular format otherwise. (This applies to statements terminated by ; or \G.) auto_vertical_output = False # keyword casing preference. Possible values "lower", "upper", "auto" keyword_casing = auto # disabled pager on startup enable_pager = True # Choose a specific pager pager = less [keys] # possible values: auto, fzf, reverse_isearch control_r = auto # Custom colors for the completion menu, toolbar, etc. [colors] completion-menu.completion.current = "bg:#ffffff #000000" completion-menu.completion = "bg:#008888 #ffffff" completion-menu.meta.completion.current = "bg:#44aaaa #000000" completion-menu.meta.completion = "bg:#448888 #ffffff" completion-menu.multi-column-meta = "bg:#aaffff #000000" scrollbar.arrow = "bg:#003333" scrollbar = "bg:#00aaaa" selected = "#ffffff bg:#6666aa" search = "#ffffff bg:#4444aa" search.current = "#ffffff bg:#44aa44" bottom-toolbar = "bg:#222222 #aaaaaa" bottom-toolbar.off = "bg:#222222 #888888" bottom-toolbar.on = "bg:#222222 #ffffff" search-toolbar = noinherit bold search-toolbar.text = nobold system-toolbar = noinherit bold arg-toolbar = noinherit bold arg-toolbar.text = nobold bottom-toolbar.transaction.valid = "bg:#222222 #00ff5f bold" bottom-toolbar.transaction.failed = "bg:#222222 #ff005f bold" # style classes for colored table output output.header = "#00ff5f bold" output.odd-row = "" output.even-row = "" output.null = "#808080" # SQL syntax highlighting overrides # sql.comment = 'italic #408080' # sql.comment.multi-line = '' # sql.comment.single-line = '' # sql.comment.optimizer-hint = '' # sql.escape = 'border:#FF0000' # sql.keyword = 'bold #008000' # sql.datatype = 'nobold #B00040' # sql.literal = '' # sql.literal.date = '' # sql.symbol = '' # sql.quoted-schema-object = '' # sql.quoted-schema-object.escape = '' # sql.constant = '#880000' # sql.function = '#0000FF' # sql.variable = '#19177C' # sql.number = '#666666' # sql.number.binary = '' # sql.number.float = '' # sql.number.hex = '' # sql.number.integer = '' # sql.operator = '#666666' # sql.punctuation = '' # sql.string = '#BA2121' # sql.string.double-quouted = '' # sql.string.escape = 'bold #BB6622' # sql.string.single-quoted = '' # sql.whitespace = '' # Favorite queries. # You can add your favorite queries here. They will be available in the # REPL when you type `\f` or `\f `. [favorite_queries] check = 'select "✔"' foo_args = 'SELECT $1, "$2", "$3"' # example = "SELECT * FROM example_table WHERE id = 1" # Initial commands to execute when connecting to any database. [init-commands] global_limit = set sql_select_limit=9999 # read_only = "SET SESSION TRANSACTION READ ONLY" # Use the -d option to reference a DSN. # Special characters in passwords and other strings can be escaped with URL encoding. [alias_dsn] # example_dsn = mysql://[user[:password]@][host][:port][/dbname] # Initial commands to execute when connecting to a DSN alias. [alias_dsn.init-commands] # Define one or more SQL statements per alias (semicolon-separated). # example_dsn = "SET sql_select_limit=1000; SET time_zone='+00:00'" ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/mylogin.cnf0000644000175100017510000000023415101406164015502 0ustar00runnerrunner    ZJ})@ ޫRF |(^ώ }aɊdj"O  10 AND ", "SELECT * FROM tabl WHERE (bar AND (baz OR (qux AND (", "SELECT * FROM tabl WHERE 10 < ", "SELECT * FROM tabl WHERE foo BETWEEN ", "SELECT * FROM tabl WHERE foo BETWEEN foo AND ", ], ) def test_where_suggests_columns_functions(expression): suggestions = suggest_type(expression, expression) assert sorted_dicts(suggestions) == sorted_dicts([ {"type": "alias", "aliases": ["tabl"]}, {"type": "column", "tables": [(None, "tabl", None)]}, {"type": "function", "schema": []}, {"type": "keyword"}, ]) @pytest.mark.parametrize( "expression", [ "SELECT * FROM tabl WHERE foo IN (", "SELECT * FROM tabl WHERE foo IN (bar, ", ], ) def test_where_in_suggests_columns(expression): suggestions = suggest_type(expression, expression) assert sorted_dicts(suggestions) == sorted_dicts([ {"type": "alias", "aliases": ["tabl"]}, {"type": "column", "tables": [(None, "tabl", None)]}, {"type": "function", "schema": []}, {"type": "keyword"}, ]) def test_where_equals_any_suggests_columns_or_keywords(): text = "SELECT * FROM tabl WHERE foo = ANY(" suggestions = suggest_type(text, text) assert sorted_dicts(suggestions) == sorted_dicts([ {"type": "alias", "aliases": ["tabl"]}, {"type": "column", "tables": [(None, "tabl", None)]}, {"type": "function", "schema": []}, {"type": "keyword"}, ]) def test_lparen_suggests_cols(): suggestion = suggest_type("SELECT MAX( FROM tbl", "SELECT MAX(") assert suggestion == [{"type": "column", "tables": [(None, "tbl", None)]}] def test_operand_inside_function_suggests_cols1(): suggestion = suggest_type("SELECT MAX(col1 + FROM tbl", "SELECT MAX(col1 + ") assert suggestion == [{"type": "column", "tables": [(None, "tbl", None)]}] def test_operand_inside_function_suggests_cols2(): suggestion = suggest_type("SELECT MAX(col1 + col2 + FROM tbl", "SELECT MAX(col1 + col2 + ") assert suggestion == [{"type": "column", "tables": [(None, "tbl", None)]}] def test_select_suggests_cols_and_funcs(): suggestions = suggest_type("SELECT ", "SELECT ") assert sorted_dicts(suggestions) == sorted_dicts([ {"type": "alias", "aliases": []}, {"type": "column", "tables": []}, {"type": "function", "schema": []}, {"type": "keyword"}, ]) @pytest.mark.parametrize( "expression", [ "SELECT * FROM ", "INSERT INTO ", "COPY ", "UPDATE ", "DESCRIBE ", "DESC ", "EXPLAIN ", "SELECT * FROM foo JOIN ", ], ) def test_expression_suggests_tables_views_and_schemas(expression): suggestions = suggest_type(expression, expression) assert sorted_dicts(suggestions) == sorted_dicts([{"type": "table", "schema": []}, {"type": "view", "schema": []}, {"type": "schema"}]) @pytest.mark.parametrize( "expression", [ "SELECT * FROM sch.", "INSERT INTO sch.", "COPY sch.", "UPDATE sch.", "DESCRIBE sch.", "DESC sch.", "EXPLAIN sch.", "SELECT * FROM foo JOIN sch.", ], ) def test_expression_suggests_qualified_tables_views_and_schemas(expression): suggestions = suggest_type(expression, expression) assert sorted_dicts(suggestions) == sorted_dicts([{"type": "table", "schema": "sch"}, {"type": "view", "schema": "sch"}]) def test_truncate_suggests_tables_and_schemas(): suggestions = suggest_type("TRUNCATE ", "TRUNCATE ") assert sorted_dicts(suggestions) == sorted_dicts([{"type": "table", "schema": []}, {"type": "schema"}]) def test_truncate_suggests_qualified_tables(): suggestions = suggest_type("TRUNCATE sch.", "TRUNCATE sch.") assert sorted_dicts(suggestions) == sorted_dicts([{"type": "table", "schema": "sch"}]) def test_distinct_suggests_cols(): suggestions = suggest_type("SELECT DISTINCT ", "SELECT DISTINCT ") assert suggestions == [{"type": "column", "tables": []}] def test_col_comma_suggests_cols(): suggestions = suggest_type("SELECT a, b, FROM tbl", "SELECT a, b,") assert sorted_dicts(suggestions) == sorted_dicts([ {"type": "alias", "aliases": ["tbl"]}, {"type": "column", "tables": [(None, "tbl", None)]}, {"type": "function", "schema": []}, {"type": "keyword"}, ]) def test_table_comma_suggests_tables_and_schemas(): suggestions = suggest_type("SELECT a, b FROM tbl1, ", "SELECT a, b FROM tbl1, ") assert sorted_dicts(suggestions) == sorted_dicts([{"type": "table", "schema": []}, {"type": "view", "schema": []}, {"type": "schema"}]) def test_into_suggests_tables_and_schemas(): suggestion = suggest_type("INSERT INTO ", "INSERT INTO ") assert sorted_dicts(suggestion) == sorted_dicts([{"type": "table", "schema": []}, {"type": "view", "schema": []}, {"type": "schema"}]) def test_insert_into_lparen_suggests_cols(): suggestions = suggest_type("INSERT INTO abc (", "INSERT INTO abc (") assert suggestions == [{"type": "column", "tables": [(None, "abc", None)]}] def test_insert_into_lparen_partial_text_suggests_cols(): suggestions = suggest_type("INSERT INTO abc (i", "INSERT INTO abc (i") assert suggestions == [{"type": "column", "tables": [(None, "abc", None)]}] def test_insert_into_lparen_comma_suggests_cols(): suggestions = suggest_type("INSERT INTO abc (id,", "INSERT INTO abc (id,") assert suggestions == [{"type": "column", "tables": [(None, "abc", None)]}] def test_partially_typed_col_name_suggests_col_names(): suggestions = suggest_type("SELECT * FROM tabl WHERE col_n", "SELECT * FROM tabl WHERE col_n") assert sorted_dicts(suggestions) == sorted_dicts([ {"type": "alias", "aliases": ["tabl"]}, {"type": "column", "tables": [(None, "tabl", None)]}, {"type": "function", "schema": []}, {"type": "keyword"}, ]) def test_dot_suggests_cols_of_a_table_or_schema_qualified_table(): suggestions = suggest_type("SELECT tabl. FROM tabl", "SELECT tabl.") assert sorted_dicts(suggestions) == sorted_dicts([ {"type": "column", "tables": [(None, "tabl", None)]}, {"type": "table", "schema": "tabl"}, {"type": "view", "schema": "tabl"}, {"type": "function", "schema": "tabl"}, ]) def test_dot_suggests_cols_of_an_alias(): suggestions = suggest_type("SELECT t1. FROM tabl1 t1, tabl2 t2", "SELECT t1.") assert sorted_dicts(suggestions) == sorted_dicts([ {"type": "table", "schema": "t1"}, {"type": "view", "schema": "t1"}, {"type": "column", "tables": [(None, "tabl1", "t1")]}, {"type": "function", "schema": "t1"}, ]) def test_dot_col_comma_suggests_cols_or_schema_qualified_table(): suggestions = suggest_type("SELECT t1.a, t2. FROM tabl1 t1, tabl2 t2", "SELECT t1.a, t2.") assert sorted_dicts(suggestions) == sorted_dicts([ {"type": "column", "tables": [(None, "tabl2", "t2")]}, {"type": "table", "schema": "t2"}, {"type": "view", "schema": "t2"}, {"type": "function", "schema": "t2"}, ]) @pytest.mark.parametrize( "expression", [ "SELECT * FROM (", "SELECT * FROM foo WHERE EXISTS (", "SELECT * FROM foo WHERE bar AND NOT EXISTS (", "SELECT 1 AS", ], ) def test_sub_select_suggests_keyword(expression): suggestion = suggest_type(expression, expression) assert suggestion == [{"type": "keyword"}] @pytest.mark.parametrize( "expression", [ "SELECT * FROM (S", "SELECT * FROM foo WHERE EXISTS (S", "SELECT * FROM foo WHERE bar AND NOT EXISTS (S", ], ) def test_sub_select_partial_text_suggests_keyword(expression): suggestion = suggest_type(expression, expression) assert suggestion == [{"type": "keyword"}] def test_outer_table_reference_in_exists_subquery_suggests_columns(): q = "SELECT * FROM foo f WHERE EXISTS (SELECT 1 FROM bar WHERE f." suggestions = suggest_type(q, q) assert suggestions == [ {"type": "column", "tables": [(None, "foo", "f")]}, {"type": "table", "schema": "f"}, {"type": "view", "schema": "f"}, {"type": "function", "schema": "f"}, ] @pytest.mark.parametrize( "expression", [ "SELECT * FROM (SELECT * FROM ", "SELECT * FROM foo WHERE EXISTS (SELECT * FROM ", "SELECT * FROM foo WHERE bar AND NOT EXISTS (SELECT * FROM ", ], ) def test_sub_select_table_name_completion(expression): suggestion = suggest_type(expression, expression) assert sorted_dicts(suggestion) == sorted_dicts([{"type": "table", "schema": []}, {"type": "view", "schema": []}, {"type": "schema"}]) def test_sub_select_col_name_completion(): suggestions = suggest_type("SELECT * FROM (SELECT FROM abc", "SELECT * FROM (SELECT ") assert sorted_dicts(suggestions) == sorted_dicts([ {"type": "alias", "aliases": ["abc"]}, {"type": "column", "tables": [(None, "abc", None)]}, {"type": "function", "schema": []}, {"type": "keyword"}, ]) @pytest.mark.xfail def test_sub_select_multiple_col_name_completion(): suggestions = suggest_type("SELECT * FROM (SELECT a, FROM abc", "SELECT * FROM (SELECT a, ") assert sorted_dicts(suggestions) == sorted_dicts([ {"type": "column", "tables": [(None, "abc", None)]}, {"type": "function", "schema": []}, ]) def test_sub_select_dot_col_name_completion(): suggestions = suggest_type("SELECT * FROM (SELECT t. FROM tabl t", "SELECT * FROM (SELECT t.") assert sorted_dicts(suggestions) == sorted_dicts([ {"type": "column", "tables": [(None, "tabl", "t")]}, {"type": "table", "schema": "t"}, {"type": "view", "schema": "t"}, {"type": "function", "schema": "t"}, ]) @pytest.mark.parametrize("join_type", ["", "INNER", "LEFT", "RIGHT OUTER"]) @pytest.mark.parametrize("tbl_alias", ["", "foo"]) def test_join_suggests_tables_and_schemas(tbl_alias, join_type): text = f"SELECT * FROM abc {tbl_alias} {join_type} JOIN " suggestion = suggest_type(text, text) assert sorted_dicts(suggestion) == sorted_dicts([{"type": "table", "schema": []}, {"type": "view", "schema": []}, {"type": "schema"}]) @pytest.mark.parametrize( "sql", [ "SELECT * FROM abc a JOIN def d ON a.", "SELECT * FROM abc a JOIN def d ON a.id = d.id AND a.", ], ) def test_join_alias_dot_suggests_cols1(sql): suggestions = suggest_type(sql, sql) assert sorted_dicts(suggestions) == sorted_dicts([ {"type": "column", "tables": [(None, "abc", "a")]}, {"type": "table", "schema": "a"}, {"type": "view", "schema": "a"}, {"type": "function", "schema": "a"}, ]) @pytest.mark.parametrize( "sql", [ "SELECT * FROM abc a JOIN def d ON a.id = d.", "SELECT * FROM abc a JOIN def d ON a.id = d.id AND a.id2 = d.", ], ) def test_join_alias_dot_suggests_cols2(sql): suggestions = suggest_type(sql, sql) assert sorted_dicts(suggestions) == sorted_dicts([ {"type": "column", "tables": [(None, "def", "d")]}, {"type": "table", "schema": "d"}, {"type": "view", "schema": "d"}, {"type": "function", "schema": "d"}, ]) @pytest.mark.parametrize( "sql", [ "select a.x, b.y from abc a join bcd b on ", "select a.x, b.y from abc a join bcd b on a.id = b.id OR ", ], ) def test_on_suggests_aliases(sql): suggestions = suggest_type(sql, sql) assert suggestions == [{"type": "alias", "aliases": ["a", "b"]}] @pytest.mark.parametrize( "sql", [ "select abc.x, bcd.y from abc join bcd on ", "select abc.x, bcd.y from abc join bcd on abc.id = bcd.id AND ", ], ) def test_on_suggests_tables(sql): suggestions = suggest_type(sql, sql) assert suggestions == [{"type": "alias", "aliases": ["abc", "bcd"]}] @pytest.mark.parametrize( "sql", [ "select a.x, b.y from abc a join bcd b on a.id = ", "select a.x, b.y from abc a join bcd b on a.id = b.id AND a.id2 = ", ], ) def test_on_suggests_aliases_right_side(sql): suggestions = suggest_type(sql, sql) assert suggestions == [{"type": "alias", "aliases": ["a", "b"]}] @pytest.mark.parametrize( "sql", [ "select abc.x, bcd.y from abc join bcd on ", "select abc.x, bcd.y from abc join bcd on abc.id = bcd.id and ", ], ) def test_on_suggests_tables_right_side(sql): suggestions = suggest_type(sql, sql) assert suggestions == [{"type": "alias", "aliases": ["abc", "bcd"]}] @pytest.mark.parametrize("col_list", ["", "col1, "]) def test_join_using_suggests_common_columns(col_list): text = "select * from abc inner join def using (" + col_list assert suggest_type(text, text) == [{"type": "column", "tables": [(None, "abc", None), (None, "def", None)], "drop_unique": True}] @pytest.mark.parametrize( "sql", [ "SELECT * FROM abc a JOIN def d ON a.id = d.id JOIN ghi g ON g.", "SELECT * FROM abc a JOIN def d ON a.id = d.id AND a.id2 = d.id2 JOIN ghi g ON d.id = g.id AND g.", ], ) def test_two_join_alias_dot_suggests_cols1(sql): suggestions = suggest_type(sql, sql) assert sorted_dicts(suggestions) == sorted_dicts([ {"type": "column", "tables": [(None, "ghi", "g")]}, {"type": "table", "schema": "g"}, {"type": "view", "schema": "g"}, {"type": "function", "schema": "g"}, ]) def test_2_statements_2nd_current(): suggestions = suggest_type("select * from a; select * from ", "select * from a; select * from ") assert sorted_dicts(suggestions) == sorted_dicts([{"type": "table", "schema": []}, {"type": "view", "schema": []}, {"type": "schema"}]) suggestions = suggest_type("select * from a; select from b", "select * from a; select ") assert sorted_dicts(suggestions) == sorted_dicts([ {"type": "alias", "aliases": ["b"]}, {"type": "column", "tables": [(None, "b", None)]}, {"type": "function", "schema": []}, {"type": "keyword"}, ]) # Should work even if first statement is invalid suggestions = suggest_type("select * from; select * from ", "select * from; select * from ") assert sorted_dicts(suggestions) == sorted_dicts([{"type": "table", "schema": []}, {"type": "view", "schema": []}, {"type": "schema"}]) def test_2_statements_1st_current(): suggestions = suggest_type("select * from ; select * from b", "select * from ") assert sorted_dicts(suggestions) == sorted_dicts([{"type": "table", "schema": []}, {"type": "view", "schema": []}, {"type": "schema"}]) suggestions = suggest_type("select from a; select * from b", "select ") assert sorted_dicts(suggestions) == sorted_dicts([ {"type": "alias", "aliases": ["a"]}, {"type": "column", "tables": [(None, "a", None)]}, {"type": "function", "schema": []}, {"type": "keyword"}, ]) def test_3_statements_2nd_current(): suggestions = suggest_type("select * from a; select * from ; select * from c", "select * from a; select * from ") assert sorted_dicts(suggestions) == sorted_dicts([{"type": "table", "schema": []}, {"type": "view", "schema": []}, {"type": "schema"}]) suggestions = suggest_type("select * from a; select from b; select * from c", "select * from a; select ") assert sorted_dicts(suggestions) == sorted_dicts([ {"type": "alias", "aliases": ["b"]}, {"type": "column", "tables": [(None, "b", None)]}, {"type": "function", "schema": []}, {"type": "keyword"}, ]) def test_create_db_with_template(): suggestions = suggest_type("create database foo with template ", "create database foo with template ") assert sorted_dicts(suggestions) == sorted_dicts([{"type": "database"}]) @pytest.mark.parametrize("initial_text", ["", " ", "\t \t"]) def test_specials_included_for_initial_completion(initial_text): suggestions = suggest_type(initial_text, initial_text) assert sorted_dicts(suggestions) == sorted_dicts([{"type": "keyword"}, {"type": "special"}]) def test_specials_not_included_after_initial_token(): suggestions = suggest_type("create table foo (dt d", "create table foo (dt d") assert sorted_dicts(suggestions) == sorted_dicts([{"type": "keyword"}]) def test_drop_schema_qualified_table_suggests_only_tables(): text = "DROP TABLE schema_name.table_name" suggestions = suggest_type(text, text) assert suggestions == [{"type": "table", "schema": "schema_name"}] @pytest.mark.parametrize("text", [",", " ,", "sel ,"]) def test_handle_pre_completion_comma_gracefully(text): suggestions = suggest_type(text, text) assert iter(suggestions) def test_cross_join(): text = "select * from v1 cross join v2 JOIN v1.id, " suggestions = suggest_type(text, text) assert sorted_dicts(suggestions) == sorted_dicts([{"type": "table", "schema": []}, {"type": "view", "schema": []}, {"type": "schema"}]) @pytest.mark.parametrize( "expression", [ "SELECT 1 AS ", "SELECT 1 FROM tabl AS ", ], ) def test_after_as(expression): suggestions = suggest_type(expression, expression) assert set(suggestions) == set() @pytest.mark.parametrize( "expression", [ "\\. ", "select 1; \\. ", "select 1;\\. ", "select 1 ; \\. ", "source ", "truncate table test; source ", "truncate table test ; source ", "truncate table test;source ", ], ) def test_source_is_file(expression): suggestions = suggest_type(expression, expression) assert suggestions == [{"type": "file_name"}] @pytest.mark.parametrize( "expression", [ "\\f ", ], ) def test_favorite_name_suggestion(expression): suggestions = suggest_type(expression, expression) assert suggestions == [{"type": "favoritequery"}] def test_order_by(): text = "select * from foo order by " suggestions = suggest_type(text, text) assert suggestions == [{"tables": [(None, "foo", None)], "type": "column"}] def test_quoted_where(): text = "'where i=';" suggestions = suggest_type(text, text) assert suggestions == [{"type": "keyword"}] ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/test_completion_refresher.py0000644000175100017510000000463715101406164021176 0ustar00runnerrunner# type: ignore import time from unittest.mock import Mock, patch import pytest @pytest.fixture def refresher(): from mycli.completion_refresher import CompletionRefresher return CompletionRefresher() def test_ctor(refresher): """Refresher object should contain a few handlers. :param refresher: :return: """ assert len(refresher.refreshers) > 0 actual_handlers = list(refresher.refreshers.keys()) expected_handlers = ["databases", "schemata", "tables", "users", "functions", "special_commands", "show_commands", "keywords"] assert expected_handlers == actual_handlers def test_refresh_called_once(refresher): """ :param refresher: :return: """ callbacks = Mock() sqlexecute = Mock() with patch.object(refresher, "_bg_refresh") as bg_refresh: actual = refresher.refresh(sqlexecute, callbacks) time.sleep(1) # Wait for the thread to work. assert len(actual) == 1 assert len(actual[0]) == 4 assert actual[0][3] == "Auto-completion refresh started in the background." bg_refresh.assert_called_with(sqlexecute, callbacks, {}) def test_refresh_called_twice(refresher): """If refresh is called a second time, it should be restarted. :param refresher: :return: """ callbacks = Mock() sqlexecute = Mock() def dummy_bg_refresh(*args): time.sleep(3) # seconds refresher._bg_refresh = dummy_bg_refresh actual1 = refresher.refresh(sqlexecute, callbacks) time.sleep(1) # Wait for the thread to work. assert len(actual1) == 1 assert len(actual1[0]) == 4 assert actual1[0][3] == "Auto-completion refresh started in the background." actual2 = refresher.refresh(sqlexecute, callbacks) time.sleep(1) # Wait for the thread to work. assert len(actual2) == 1 assert len(actual2[0]) == 4 assert actual2[0][3] == "Auto-completion refresh restarted." def test_refresh_with_callbacks(refresher): """Callbacks must be called. :param refresher: """ callbacks = [Mock()] sqlexecute_class = Mock() sqlexecute = Mock() with patch("mycli.completion_refresher.SQLExecute", sqlexecute_class): # Set refreshers to 0: we're not testing refresh logic here refresher.refreshers = {} refresher.refresh(sqlexecute, callbacks) time.sleep(1) # Wait for the thread to work. assert callbacks[0].call_count == 1 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/test_config.py0000644000175100017510000001332715101406164016221 0ustar00runnerrunner# type: ignore """Unit tests for the mycli.config module.""" from io import BytesIO, StringIO, TextIOWrapper import os import struct import sys import tempfile import pytest from mycli.config import ( get_mylogin_cnf_path, open_mylogin_cnf, read_and_decrypt_mylogin_cnf, read_config_file, str_to_bool, strip_matching_quotes, ) LOGIN_PATH_FILE = os.path.abspath(os.path.join(os.path.dirname(__file__), "mylogin.cnf")) def open_bmylogin_cnf(name): """Open contents of *name* in a BytesIO buffer.""" with open(name, "rb") as f: buf = BytesIO() buf.write(f.read()) return buf def test_read_mylogin_cnf(): """Tests that a login path file can be read and decrypted.""" mylogin_cnf = open_mylogin_cnf(LOGIN_PATH_FILE) assert isinstance(mylogin_cnf, TextIOWrapper) contents = mylogin_cnf.read() for word in ("[test]", "user", "password", "host", "port"): assert word in contents def test_decrypt_blank_mylogin_cnf(): """Test that a blank login path file is handled correctly.""" mylogin_cnf = read_and_decrypt_mylogin_cnf(BytesIO()) assert mylogin_cnf is None def test_corrupted_login_key(): """Test that a corrupted login path key is handled correctly.""" buf = open_bmylogin_cnf(LOGIN_PATH_FILE) # Skip past the unused bytes buf.seek(4) # Write null bytes over half the login key buf.write(b"\0\0\0\0\0\0\0\0\0\0") buf.seek(0) mylogin_cnf = read_and_decrypt_mylogin_cnf(buf) assert mylogin_cnf is None def test_corrupted_pad(): """Tests that a login path file with a corrupted pad is partially read.""" buf = open_bmylogin_cnf(LOGIN_PATH_FILE) # Skip past the login key buf.seek(24) # Skip option group len_buf = buf.read(4) (cipher_len,) = struct.unpack(" pager output(monkeypatch, terminal_size=(5, 10), testdata=testdata, explicit_pager=False, expect_pager=True) # User didn't set pager, output fits screen -> no pager output(monkeypatch, terminal_size=(20, 20), testdata=testdata, explicit_pager=False, expect_pager=False) # User manually configured pager, output doesn't fit screen -> pager output(monkeypatch, terminal_size=(5, 10), testdata=testdata, explicit_pager=True, expect_pager=True) # User manually configured pager, output fit screen -> pager output(monkeypatch, terminal_size=(20, 20), testdata=testdata, explicit_pager=True, expect_pager=True) SPECIAL_COMMANDS["nopager"].handler() output(monkeypatch, terminal_size=(5, 10), testdata=testdata, explicit_pager=False, expect_pager=False) SPECIAL_COMMANDS["pager"].handler("") def test_reserved_space_is_integer(monkeypatch): """Make sure that reserved space is returned as an integer.""" def stub_terminal_size(): return (5, 5) with monkeypatch.context() as m: m.setattr(shutil, "get_terminal_size", stub_terminal_size) mycli = MyCli() assert isinstance(mycli.get_reserved_space(), int) def test_list_dsn(): runner = CliRunner() # keep Windows from locking the file with delete=False with NamedTemporaryFile(mode="w", delete=False) as myclirc: myclirc.write( dedent("""\ [alias_dsn] test = mysql://test/test """) ) myclirc.flush() args = ["--list-dsn", "--myclirc", myclirc.name] result = runner.invoke(cli, args=args) assert result.output == "test\n" result = runner.invoke(cli, args=args + ["--verbose"]) assert result.output == "test : mysql://test/test\n" # delete=False means we should try to clean up try: if os.path.exists(myclirc.name): os.remove(myclirc.name) except Exception as e: print(f"An error occurred while attempting to delete the file: {e}") def test_prettify_statement(): statement = "SELECT 1" m = MyCli() pretty_statement = m.handle_prettify_binding(statement) assert pretty_statement == "SELECT\n 1;" def test_unprettify_statement(): statement = "SELECT\n 1" m = MyCli() unpretty_statement = m.handle_unprettify_binding(statement) assert unpretty_statement == "SELECT 1;" def test_list_ssh_config(): runner = CliRunner() # keep Windows from locking the file with delete=False with NamedTemporaryFile(mode="w", delete=False) as ssh_config: ssh_config.write( dedent("""\ Host test Hostname test.example.com User joe Port 22222 IdentityFile ~/.ssh/gateway """) ) ssh_config.flush() args = ["--list-ssh-config", "--ssh-config-path", ssh_config.name] result = runner.invoke(cli, args=args) assert "test\n" in result.output result = runner.invoke(cli, args=args + ["--verbose"]) assert "test : test.example.com\n" in result.output # delete=False means we should try to clean up try: if os.path.exists(ssh_config.name): os.remove(ssh_config.name) except Exception as e: print(f"An error occurred while attempting to delete the file: {e}") def test_dsn(monkeypatch): # Setup classes to mock mycli.main.MyCli class Formatter: format_name = None class Logger: def debug(self, *args, **args_dict): pass def warning(self, *args, **args_dict): pass class MockMyCli: config = {"alias_dsn": {}} def __init__(self, **args): self.logger = Logger() self.destructive_warning = False self.main_formatter = Formatter() self.redirect_formatter = Formatter() def connect(self, **args): MockMyCli.connect_args = args def run_query(self, query, new_line=True): pass import mycli.main monkeypatch.setattr(mycli.main, "MyCli", MockMyCli) runner = CliRunner() # When a user supplies a DSN as database argument to mycli, # use these values. result = runner.invoke(mycli.main.cli, args=["mysql://dsn_user:dsn_passwd@dsn_host:1/dsn_database"]) assert result.exit_code == 0, result.output + " " + str(result.exception) assert ( MockMyCli.connect_args["user"] == "dsn_user" and MockMyCli.connect_args["passwd"] == "dsn_passwd" and MockMyCli.connect_args["host"] == "dsn_host" and MockMyCli.connect_args["port"] == 1 and MockMyCli.connect_args["database"] == "dsn_database" ) MockMyCli.connect_args = None # When a use supplies a DSN as database argument to mycli, # and used command line arguments, use the command line # arguments. result = runner.invoke( mycli.main.cli, args=[ "mysql://dsn_user:dsn_passwd@dsn_host:2/dsn_database", "--user", "arg_user", "--password", "arg_password", "--host", "arg_host", "--port", "3", "--database", "arg_database", ], ) assert result.exit_code == 0, result.output + " " + str(result.exception) assert ( MockMyCli.connect_args["user"] == "arg_user" and MockMyCli.connect_args["passwd"] == "arg_password" and MockMyCli.connect_args["host"] == "arg_host" and MockMyCli.connect_args["port"] == 3 and MockMyCli.connect_args["database"] == "arg_database" ) MockMyCli.config = {"alias_dsn": {"test": "mysql://alias_dsn_user:alias_dsn_passwd@alias_dsn_host:4/alias_dsn_database"}} MockMyCli.connect_args = None # When a user uses a DSN from the configuration file (alias_dsn), # use these values. result = runner.invoke(cli, args=["--dsn", "test"]) assert result.exit_code == 0, result.output + " " + str(result.exception) assert ( MockMyCli.connect_args["user"] == "alias_dsn_user" and MockMyCli.connect_args["passwd"] == "alias_dsn_passwd" and MockMyCli.connect_args["host"] == "alias_dsn_host" and MockMyCli.connect_args["port"] == 4 and MockMyCli.connect_args["database"] == "alias_dsn_database" ) MockMyCli.config = {"alias_dsn": {"test": "mysql://alias_dsn_user:alias_dsn_passwd@alias_dsn_host:4/alias_dsn_database"}} MockMyCli.connect_args = None # When a user uses a DSN from the configuration file (alias_dsn) # and used command line arguments, use the command line arguments. result = runner.invoke( cli, args=[ "--dsn", "test", "", "--user", "arg_user", "--password", "arg_password", "--host", "arg_host", "--port", "5", "--database", "arg_database", ], ) assert result.exit_code == 0, result.output + " " + str(result.exception) assert ( MockMyCli.connect_args["user"] == "arg_user" and MockMyCli.connect_args["passwd"] == "arg_password" and MockMyCli.connect_args["host"] == "arg_host" and MockMyCli.connect_args["port"] == 5 and MockMyCli.connect_args["database"] == "arg_database" ) # Use a DSN without password result = runner.invoke(mycli.main.cli, args=["mysql://dsn_user@dsn_host:6/dsn_database"]) assert result.exit_code == 0, result.output + " " + str(result.exception) assert ( MockMyCli.connect_args["user"] == "dsn_user" and MockMyCli.connect_args["passwd"] is None and MockMyCli.connect_args["host"] == "dsn_host" and MockMyCli.connect_args["port"] == 6 and MockMyCli.connect_args["database"] == "dsn_database" ) # Use a DSN with query parameters result = runner.invoke(mycli.main.cli, args=["mysql://dsn_user:dsn_passwd@dsn_host:6/dsn_database?ssl=True"]) assert result.exit_code == 0, result.output + " " + str(result.exception) assert ( MockMyCli.connect_args["user"] == "dsn_user" and MockMyCli.connect_args["passwd"] == "dsn_passwd" and MockMyCli.connect_args["host"] == "dsn_host" and MockMyCli.connect_args["port"] == 6 and MockMyCli.connect_args["database"] == "dsn_database" and MockMyCli.connect_args["ssl"]["enable"] is True ) # When a user uses a DSN with query parameters, and used command line # arguments, use the command line arguments. result = runner.invoke( mycli.main.cli, args=[ "mysql://dsn_user:dsn_passwd@dsn_host:6/dsn_database?ssl=False", "--ssl", ], ) assert result.exit_code == 0, result.output + " " + str(result.exception) assert ( MockMyCli.connect_args["user"] == "dsn_user" and MockMyCli.connect_args["passwd"] == "dsn_passwd" and MockMyCli.connect_args["host"] == "dsn_host" and MockMyCli.connect_args["port"] == 6 and MockMyCli.connect_args["database"] == "dsn_database" and MockMyCli.connect_args["ssl"]["enable"] is True ) def test_ssh_config(monkeypatch): # Setup classes to mock mycli.main.MyCli class Formatter: format_name = None class Logger: def debug(self, *args, **args_dict): pass def warning(self, *args, **args_dict): pass class MockMyCli: config = {"alias_dsn": {}} def __init__(self, **args): self.logger = Logger() self.destructive_warning = False self.main_formatter = Formatter() self.redirect_formatter = Formatter() def connect(self, **args): MockMyCli.connect_args = args def run_query(self, query, new_line=True): pass import mycli.main monkeypatch.setattr(mycli.main, "MyCli", MockMyCli) runner = CliRunner() # Setup temporary configuration # keep Windows from locking the file with delete=False with NamedTemporaryFile(mode="w", delete=False) as ssh_config: ssh_config.write( dedent("""\ Host test Hostname test.example.com User joe Port 22222 IdentityFile ~/.ssh/gateway """) ) ssh_config.flush() # When a user supplies a ssh config. result = runner.invoke(mycli.main.cli, args=["--ssh-config-path", ssh_config.name, "--ssh-config-host", "test"]) assert result.exit_code == 0, result.output + " " + str(result.exception) assert ( MockMyCli.connect_args["ssh_user"] == "joe" and MockMyCli.connect_args["ssh_host"] == "test.example.com" and MockMyCli.connect_args["ssh_port"] == 22222 and MockMyCli.connect_args["ssh_key_filename"] == os.path.expanduser("~") + "/.ssh/gateway" ) # When a user supplies a ssh config host as argument to mycli, # and used command line arguments, use the command line # arguments. result = runner.invoke( mycli.main.cli, args=[ "--ssh-config-path", ssh_config.name, "--ssh-config-host", "test", "--ssh-user", "arg_user", "--ssh-host", "arg_host", "--ssh-port", "3", "--ssh-key-filename", "/path/to/key", ], ) assert result.exit_code == 0, result.output + " " + str(result.exception) assert ( MockMyCli.connect_args["ssh_user"] == "arg_user" and MockMyCli.connect_args["ssh_host"] == "arg_host" and MockMyCli.connect_args["ssh_port"] == 3 and MockMyCli.connect_args["ssh_key_filename"] == "/path/to/key" ) # delete=False means we should try to clean up try: if os.path.exists(ssh_config.name): os.remove(ssh_config.name) except Exception as e: print(f"An error occurred while attempting to delete the file: {e}") @dbtest def test_init_command_arg(executor): init_command = "set sql_select_limit=1000" sql = 'show variables like "sql_select_limit";' runner = CliRunner() result = runner.invoke(cli, args=CLI_ARGS + ["--init-command", init_command], input=sql) expected = "sql_select_limit\t1000\n" assert result.exit_code == 0 assert expected in result.output @dbtest def test_init_command_multiple_arg(executor): init_command = "set sql_select_limit=2000; set max_join_size=20000" sql = 'show variables like "sql_select_limit";\nshow variables like "max_join_size"' runner = CliRunner() result = runner.invoke(cli, args=CLI_ARGS + ["--init-command", init_command], input=sql) expected_sql_select_limit = "sql_select_limit\t2000\n" expected_max_join_size = "max_join_size\t20000\n" assert result.exit_code == 0 assert expected_sql_select_limit in result.output assert expected_max_join_size in result.output @dbtest def test_global_init_commands(executor): """Tests that global init-commands from config are executed by default.""" # The global init-commands section in test/myclirc sets sql_select_limit=9999 sql = 'show variables like "sql_select_limit";' runner = CliRunner() result = runner.invoke(cli, args=CLI_ARGS, input=sql) expected = "sql_select_limit\t9999\n" assert result.exit_code == 0 assert expected in result.output ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/test_naive_completion.py0000644000175100017510000000343615101406164020307 0ustar00runnerrunner# type: ignore from prompt_toolkit.completion import Completion from prompt_toolkit.document import Document import pytest @pytest.fixture def completer(): import mycli.sqlcompleter as sqlcompleter return sqlcompleter.SQLCompleter(smart_completion=False) @pytest.fixture def complete_event(): from unittest.mock import Mock return Mock() def test_empty_string_completion(completer, complete_event): text = "" position = 0 result = list(completer.get_completions(Document(text=text, cursor_position=position), complete_event)) assert result == list(map(Completion, completer.all_completions)) def test_select_keyword_completion(completer, complete_event): text = "SEL" position = len("SEL") result = list(completer.get_completions(Document(text=text, cursor_position=position), complete_event)) assert result == [Completion(text="SELECT", start_position=-3)] def test_function_name_completion(completer, complete_event): text = "SELECT MA" position = len("SELECT MA") result = list(completer.get_completions(Document(text=text, cursor_position=position), complete_event)) assert sorted(x.text for x in result) == ["MASTER", "MAX"] def test_column_name_completion(completer, complete_event): text = "SELECT FROM users" position = len("SELECT ") result = list(completer.get_completions(Document(text=text, cursor_position=position), complete_event)) assert result == list(map(Completion, completer.all_completions)) def test_special_name_completion(completer, complete_event): text = "\\" position = len("\\") result = set(completer.get_completions(Document(text=text, cursor_position=position), complete_event)) # Special commands will NOT be suggested during naive completion mode. assert result == set() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/test_parseutils.py0000644000175100017510000001434715101406164017152 0ustar00runnerrunner# type: ignore import pytest from mycli.packages.parseutils import ( extract_tables, extract_tables_from_complete_statements, is_destructive, is_dropping_database, queries_start_with, query_has_where_clause, query_starts_with, ) def test_empty_string(): tables = extract_tables("") assert tables == [] def test_simple_select_single_table(): tables = extract_tables("select * from abc") assert tables == [(None, "abc", None)] def test_simple_select_single_table_schema_qualified(): tables = extract_tables("select * from abc.def") assert tables == [("abc", "def", None)] def test_simple_select_multiple_tables(): tables = extract_tables("select * from abc, def") assert sorted(tables) == [(None, "abc", None), (None, "def", None)] def test_simple_select_multiple_tables_schema_qualified(): tables = extract_tables("select * from abc.def, ghi.jkl") assert sorted(tables) == [("abc", "def", None), ("ghi", "jkl", None)] def test_simple_select_with_cols_single_table(): tables = extract_tables("select a,b from abc") assert tables == [(None, "abc", None)] def test_simple_select_with_cols_single_table_schema_qualified(): tables = extract_tables("select a,b from abc.def") assert tables == [("abc", "def", None)] def test_simple_select_with_cols_multiple_tables(): tables = extract_tables("select a,b from abc, def") assert sorted(tables) == [(None, "abc", None), (None, "def", None)] def test_simple_select_with_cols_multiple_tables_with_schema(): tables = extract_tables("select a,b from abc.def, def.ghi") assert sorted(tables) == [("abc", "def", None), ("def", "ghi", None)] def test_select_with_hanging_comma_single_table(): tables = extract_tables("select a, from abc") assert tables == [(None, "abc", None)] def test_select_with_hanging_comma_multiple_tables(): tables = extract_tables("select a, from abc, def") assert sorted(tables) == [(None, "abc", None), (None, "def", None)] def test_select_with_hanging_period_multiple_tables(): tables = extract_tables("SELECT t1. FROM tabl1 t1, tabl2 t2") assert sorted(tables) == [(None, "tabl1", "t1"), (None, "tabl2", "t2")] def test_simple_insert_single_table(): tables = extract_tables('insert into abc (id, name) values (1, "def")') # sqlparse mistakenly assigns an alias to the table # assert tables == [(None, 'abc', None)] assert tables == [(None, "abc", "abc")] def test_simple_insert_single_table_schema_qualified(): tables = extract_tables('insert into abc.def (id, name) values (1, "def")') assert tables == [("abc", "def", None)] def test_simple_update_table(): tables = extract_tables("update abc set id = 1") assert tables == [(None, "abc", None)] def test_simple_update_table_with_schema(): tables = extract_tables("update abc.def set id = 1") assert tables == [("abc", "def", None)] def test_join_table(): tables = extract_tables("SELECT * FROM abc a JOIN def d ON a.id = d.num") assert sorted(tables) == [(None, "abc", "a"), (None, "def", "d")] def test_join_table_schema_qualified(): tables = extract_tables("SELECT * FROM abc.def x JOIN ghi.jkl y ON x.id = y.num") assert tables == [("abc", "def", "x"), ("ghi", "jkl", "y")] def test_join_as_table(): tables = extract_tables("SELECT * FROM my_table AS m WHERE m.a > 5") assert tables == [(None, "my_table", "m")] def test_extract_tables_from_complete_statements(): tables = extract_tables_from_complete_statements("SELECT * FROM my_table AS m WHERE m.a > 5") assert tables == [(None, "my_table", "m")] def test_extract_tables_from_complete_statements_cte(): tables = extract_tables_from_complete_statements("WITH my_cte (id, num) AS ( SELECT id, COUNT(1) FROM my_table GROUP BY id ) SELECT *") assert tables == [(None, "my_table", None)] # this would confuse plain extract_tables() per #1122 def test_extract_tables_from_multiple_complete_statements(): tables = extract_tables_from_complete_statements(r'\T sql-insert; SELECT * FROM my_table AS m WHERE m.a > 5') assert tables == [(None, "my_table", "m")] def test_query_starts_with(): query = "USE test;" assert query_starts_with(query, ("use",)) is True query = "DROP DATABASE test;" assert query_starts_with(query, ("use",)) is False def test_query_starts_with_comment(): query = "# comment\nUSE test;" assert query_starts_with(query, ("use",)) is True def test_queries_start_with(): sql = "# comment\nshow databases;use foo;" assert queries_start_with(sql, ["show", "select"]) is True assert queries_start_with(sql, ["use", "drop"]) is True assert queries_start_with(sql, ["delete", "update"]) is False def test_is_destructive(): sql = "use test;\nshow databases;\ndrop database foo;" assert is_destructive(sql) is True def test_is_destructive_update_with_where_clause(): sql = "use test;\nshow databases;\nUPDATE test SET x = 1 WHERE id = 1;" assert is_destructive(sql) is False def test_is_destructive_update_without_where_clause(): sql = "use test;\nshow databases;\nUPDATE test SET x = 1;" assert is_destructive(sql) is True @pytest.mark.parametrize( ("sql", "has_where_clause"), [ ("update test set dummy = 1;", False), ("update test set dummy = 1 where id = 1);", True), ], ) def test_query_has_where_clause(sql, has_where_clause): assert query_has_where_clause(sql) is has_where_clause @pytest.mark.parametrize( ("sql", "dbname", "is_dropping"), [ ("select bar from foo", "foo", False), ('drop database "foo";', "`foo`", True), ("drop schema foo", "foo", True), ("drop schema foo", "bar", False), ("drop database bar", "foo", False), ("drop database foo", None, False), ("drop database foo; create database foo", "foo", False), ("drop database foo; create database bar", "foo", True), ("select bar from foo; drop database bazz", "foo", False), ("select bar from foo; drop database bazz", "bazz", True), ("-- dropping database \n drop -- really dropping \n schema abc -- now it is dropped", "abc", True), ], ) def test_is_dropping_database(sql, dbname, is_dropping): assert is_dropping_database(sql, dbname) == is_dropping ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/test_plan.wiki0000644000175100017510000000301615101406164016213 0ustar00runnerrunner= Gross Checks = * [ ] Check connecting to a local database. * [ ] Check connecting to a remote database. * [ ] Check connecting to a database with a user/password. * [ ] Check connecting to a non-existent database. * [ ] Test changing the database. == PGExecute == * [ ] Test successful execution given a cursor. * [ ] Test unsuccessful execution with a syntax error. * [ ] Test a series of executions with the same cursor without failure. * [ ] Test a series of executions with the same cursor with failure. * [ ] Test passing in a special command. == Naive Autocompletion == * [ ] Input empty string, ask for completions - Everything. * [ ] Input partial prefix, ask for completions - Stars with prefix. * [ ] Input fully autocompleted string, ask for completions - Only full match * [ ] Input non-existent prefix, ask for completions - nothing * [ ] Input lowercase prefix - case insensitive completions == Smart Autocompletion == * [ ] Input empty string and check if only keywords are returned. * [ ] Input SELECT prefix and check if only columns and '*' are returned. * [ ] Input SELECT blah - only keywords are returned. * [ ] Input SELECT * FROM - Table names only == PGSpecial == * [ ] Test \d * [ ] Test \d tablename * [ ] Test \d tablena* * [ ] Test \d non-existent-tablename * [ ] Test \d index * [ ] Test \d sequence * [ ] Test \d view == Exceptionals == * [ ] Test the 'use' command to change db. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/test_prompt_utils.py0000644000175100017510000000046615101406164017515 0ustar00runnerrunner# type: ignore import click from mycli.packages.prompt_utils import confirm_destructive_query def test_confirm_destructive_query_notty() -> None: stdin = click.get_text_stream("stdin") assert stdin.isatty() is False sql = "drop database foo;" assert confirm_destructive_query(sql) is None ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/test_smart_completion_public_schema_only.py0000644000175100017510000003223215101406164024246 0ustar00runnerrunner# type: ignore from unittest.mock import patch from prompt_toolkit.completion import Completion from prompt_toolkit.document import Document import pytest import mycli.packages.special.main as special metadata = { "users": ["id", "email", "first_name", "last_name"], "orders": ["id", "ordered_date", "status"], "select": ["id", "insert", "ABC"], "réveillé": ["id", "insert", "ABC"], } @pytest.fixture def completer(): import mycli.sqlcompleter as sqlcompleter comp = sqlcompleter.SQLCompleter(smart_completion=True) tables, columns = [], [] for table, cols in metadata.items(): tables.append((table,)) columns.extend([(table, col) for col in cols]) comp.set_dbname("test") comp.extend_schemata("test") comp.extend_relations(tables, kind="tables") comp.extend_columns(columns, kind="tables") comp.extend_special_commands(special.COMMANDS) return comp @pytest.fixture def complete_event(): from unittest.mock import Mock return Mock() def test_special_name_completion(completer, complete_event): text = "\\d" position = len("\\d") result = completer.get_completions(Document(text=text, cursor_position=position), complete_event) assert result == [Completion(text="\\dt", start_position=-2)] def test_empty_string_completion(completer, complete_event): text = "" position = 0 result = list(completer.get_completions(Document(text=text, cursor_position=position), complete_event)) assert list(map(Completion, completer.keywords + completer.special_commands)) == result def test_select_keyword_completion(completer, complete_event): text = "SEL" position = len("SEL") result = completer.get_completions(Document(text=text, cursor_position=position), complete_event) assert list(result) == [Completion(text="SELECT", start_position=-3)] def test_select_star(completer, complete_event): text = "SELECT * " position = len(text) result = completer.get_completions(Document(text=text, cursor_position=position), complete_event) assert list(result) == list(map(Completion, completer.keywords)) def test_table_completion(completer, complete_event): text = "SELECT * FROM " position = len(text) result = completer.get_completions(Document(text=text, cursor_position=position), complete_event) assert list(result) == [ Completion(text="users", start_position=0), Completion(text="orders", start_position=0), Completion(text="`select`", start_position=0), Completion(text="`réveillé`", start_position=0), ] def test_function_name_completion(completer, complete_event): text = "SELECT MA" position = len("SELECT MA") result = completer.get_completions(Document(text=text, cursor_position=position), complete_event) assert list(result) == [ Completion(text="MAX", start_position=-2), Completion(text="CHANGE MASTER TO", start_position=-2), Completion(text="CURRENT_TIMESTAMP", start_position=-2), Completion(text="DECIMAL", start_position=-2), Completion(text="FORMAT", start_position=-2), Completion(text="MASTER", start_position=-2), Completion(text="PRIMARY", start_position=-2), Completion(text="ROW_FORMAT", start_position=-2), Completion(text="SMALLINT", start_position=-2), ] def test_suggested_column_names(completer, complete_event): """Suggest column and function names when selecting from table. :param completer: :param complete_event: :return: """ text = "SELECT from users" position = len("SELECT ") result = list(completer.get_completions(Document(text=text, cursor_position=position), complete_event)) assert result == list( [ Completion(text="*", start_position=0), Completion(text="id", start_position=0), Completion(text="email", start_position=0), Completion(text="first_name", start_position=0), Completion(text="last_name", start_position=0), ] + list(map(Completion, completer.functions)) + [Completion(text="users", start_position=0)] + list(map(Completion, completer.keywords)) ) def test_suggested_column_names_in_function(completer, complete_event): """Suggest column and function names when selecting multiple columns from table. :param completer: :param complete_event: :return: """ text = "SELECT MAX( from users" position = len("SELECT MAX(") result = completer.get_completions(Document(text=text, cursor_position=position), complete_event) assert list(result) == [ Completion(text="*", start_position=0), Completion(text="id", start_position=0), Completion(text="email", start_position=0), Completion(text="first_name", start_position=0), Completion(text="last_name", start_position=0), ] def test_suggested_column_names_with_table_dot(completer, complete_event): """Suggest column names on table name and dot. :param completer: :param complete_event: :return: """ text = "SELECT users. from users" position = len("SELECT users.") result = list(completer.get_completions(Document(text=text, cursor_position=position), complete_event)) assert result == [ Completion(text="*", start_position=0), Completion(text="id", start_position=0), Completion(text="email", start_position=0), Completion(text="first_name", start_position=0), Completion(text="last_name", start_position=0), ] def test_suggested_column_names_with_alias(completer, complete_event): """Suggest column names on table alias and dot. :param completer: :param complete_event: :return: """ text = "SELECT u. from users u" position = len("SELECT u.") result = list(completer.get_completions(Document(text=text, cursor_position=position), complete_event)) assert result == [ Completion(text="*", start_position=0), Completion(text="id", start_position=0), Completion(text="email", start_position=0), Completion(text="first_name", start_position=0), Completion(text="last_name", start_position=0), ] def test_suggested_multiple_column_names(completer, complete_event): """Suggest column and function names when selecting multiple columns from table. :param completer: :param complete_event: :return: """ text = "SELECT id, from users u" position = len("SELECT id, ") result = list(completer.get_completions(Document(text=text, cursor_position=position), complete_event)) assert result == list( [ Completion(text="*", start_position=0), Completion(text="id", start_position=0), Completion(text="email", start_position=0), Completion(text="first_name", start_position=0), Completion(text="last_name", start_position=0), ] + list(map(Completion, completer.functions)) + [Completion(text="u", start_position=0)] + list(map(Completion, completer.keywords)) ) def test_suggested_multiple_column_names_with_alias(completer, complete_event): """Suggest column names on table alias and dot when selecting multiple columns from table. :param completer: :param complete_event: :return: """ text = "SELECT u.id, u. from users u" position = len("SELECT u.id, u.") result = list(completer.get_completions(Document(text=text, cursor_position=position), complete_event)) assert result == [ Completion(text="*", start_position=0), Completion(text="id", start_position=0), Completion(text="email", start_position=0), Completion(text="first_name", start_position=0), Completion(text="last_name", start_position=0), ] def test_suggested_multiple_column_names_with_dot(completer, complete_event): """Suggest column names on table names and dot when selecting multiple columns from table. :param completer: :param complete_event: :return: """ text = "SELECT users.id, users. from users u" position = len("SELECT users.id, users.") result = list(completer.get_completions(Document(text=text, cursor_position=position), complete_event)) assert result == [ Completion(text="*", start_position=0), Completion(text="id", start_position=0), Completion(text="email", start_position=0), Completion(text="first_name", start_position=0), Completion(text="last_name", start_position=0), ] def test_suggested_aliases_after_on(completer, complete_event): text = "SELECT u.name, o.id FROM users u JOIN orders o ON " position = len("SELECT u.name, o.id FROM users u JOIN orders o ON ") result = list(completer.get_completions(Document(text=text, cursor_position=position), complete_event)) assert result == [ Completion(text="u", start_position=0), Completion(text="o", start_position=0), ] def test_suggested_aliases_after_on_right_side(completer, complete_event): text = "SELECT u.name, o.id FROM users u JOIN orders o ON o.user_id = " position = len("SELECT u.name, o.id FROM users u JOIN orders o ON o.user_id = ") result = list(completer.get_completions(Document(text=text, cursor_position=position), complete_event)) assert result == [ Completion(text="u", start_position=0), Completion(text="o", start_position=0), ] def test_suggested_tables_after_on(completer, complete_event): text = "SELECT users.name, orders.id FROM users JOIN orders ON " position = len("SELECT users.name, orders.id FROM users JOIN orders ON ") result = list(completer.get_completions(Document(text=text, cursor_position=position), complete_event)) assert result == [ Completion(text="users", start_position=0), Completion(text="orders", start_position=0), ] def test_suggested_tables_after_on_right_side(completer, complete_event): text = "SELECT users.name, orders.id FROM users JOIN orders ON orders.user_id = " position = len("SELECT users.name, orders.id FROM users JOIN orders ON orders.user_id = ") result = list(completer.get_completions(Document(text=text, cursor_position=position), complete_event)) assert result == [ Completion(text="users", start_position=0), Completion(text="orders", start_position=0), ] def test_table_names_after_from(completer, complete_event): text = "SELECT * FROM " position = len("SELECT * FROM ") result = list(completer.get_completions(Document(text=text, cursor_position=position), complete_event)) assert result == [ Completion(text="users", start_position=0), Completion(text="orders", start_position=0), Completion(text="`select`", start_position=0), Completion(text="`réveillé`", start_position=0), ] def test_auto_escaped_col_names(completer, complete_event): text = "SELECT from `select`" position = len("SELECT ") result = list(completer.get_completions(Document(text=text, cursor_position=position), complete_event)) assert result == [ Completion(text="*", start_position=0), Completion(text="id", start_position=0), Completion(text="`insert`", start_position=0), Completion(text="`ABC`", start_position=0), ] + list(map(Completion, completer.functions)) + [Completion(text="select", start_position=0)] + list( map(Completion, completer.keywords) ) def test_un_escaped_table_names(completer, complete_event): text = "SELECT from réveillé" position = len("SELECT ") result = list(completer.get_completions(Document(text=text, cursor_position=position), complete_event)) assert result == list( [ Completion(text="*", start_position=0), Completion(text="id", start_position=0), Completion(text="`insert`", start_position=0), Completion(text="`ABC`", start_position=0), ] + list(map(Completion, completer.functions)) + [Completion(text="réveillé", start_position=0)] + list(map(Completion, completer.keywords)) ) def dummy_list_path(dir_name): dirs = { "/": [ "dir1", "file1.sql", "file2.sql", ], "/dir1": [ "subdir1", "subfile1.sql", "subfile2.sql", ], "/dir1/subdir1": [ "lastfile.sql", ], } return dirs.get(dir_name, []) @patch("mycli.packages.filepaths.list_path", new=dummy_list_path) @pytest.mark.parametrize( "text,expected", [ # ('source ', [('~', 0), # ('/', 0), # ('.', 0), # ('..', 0)]), ("source /", [("dir1", 0), ("file1.sql", 0), ("file2.sql", 0)]), ("source /dir1/", [("subdir1", 0), ("subfile1.sql", 0), ("subfile2.sql", 0)]), ("source /dir1/subdir1/", [("lastfile.sql", 0)]), ], ) def test_file_name_completion(completer, complete_event, text, expected): position = len(text) result = list(completer.get_completions(Document(text=text, cursor_position=position), complete_event)) expected = [Completion(txt, pos) for txt, pos in expected] assert result == expected ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/test_special_iocommands.py0000644000175100017510000002644515101406164020612 0ustar00runnerrunner# type: ignore import os import stat import tempfile from time import time from unittest.mock import patch from pymysql import ProgrammingError import pytest import mycli.packages.special from test.utils import db_connection, dbtest, send_ctrl_c def test_set_get_pager(): mycli.packages.special.set_pager_enabled(True) assert mycli.packages.special.is_pager_enabled() mycli.packages.special.set_pager_enabled(False) assert not mycli.packages.special.is_pager_enabled() mycli.packages.special.set_pager("less") assert os.environ["PAGER"] == "less" mycli.packages.special.set_pager(False) assert os.environ["PAGER"] == "less" del os.environ["PAGER"] mycli.packages.special.set_pager(False) mycli.packages.special.disable_pager() assert not mycli.packages.special.is_pager_enabled() def test_set_get_timing(): mycli.packages.special.set_timing_enabled(True) assert mycli.packages.special.is_timing_enabled() mycli.packages.special.set_timing_enabled(False) assert not mycli.packages.special.is_timing_enabled() def test_set_get_expanded_output(): mycli.packages.special.set_expanded_output(True) assert mycli.packages.special.is_expanded_output() mycli.packages.special.set_expanded_output(False) assert not mycli.packages.special.is_expanded_output() def test_editor_command(): assert mycli.packages.special.editor_command(r"hello\e") assert mycli.packages.special.editor_command(r"\ehello") assert not mycli.packages.special.editor_command(r"hello") assert mycli.packages.special.get_filename(r"\e filename") == "filename" os.environ["EDITOR"] = "true" os.environ["VISUAL"] = "true" if os.name != "nt": assert mycli.packages.special.open_external_editor(sql=r"select 1") == ('select 1', None) else: pytest.skip("Skipping on Windows platform.") def test_tee_command(): mycli.packages.special.write_tee("hello world") # write without file set # keep Windows from locking the file with delete=False with tempfile.NamedTemporaryFile(delete=False) as f: mycli.packages.special.execute(None, "tee " + f.name) mycli.packages.special.write_tee("hello world") if os.name == "nt": assert f.read() == b"hello world\r\n" else: assert f.read() == b"hello world\n" mycli.packages.special.execute(None, "tee -o " + f.name) mycli.packages.special.write_tee("hello world") f.seek(0) if os.name == "nt": assert f.read() == b"hello world\r\n" else: assert f.read() == b"hello world\n" mycli.packages.special.execute(None, "notee") mycli.packages.special.write_tee("hello world") f.seek(0) if os.name == "nt": assert f.read() == b"hello world\r\n" else: assert f.read() == b"hello world\n" # remove temp file # delete=False means we should try to clean up try: if os.path.exists(f.name): os.remove(f.name) except Exception as e: print(f"An error occurred while attempting to delete the file: {e}") def test_tee_command_error(): with pytest.raises(TypeError): mycli.packages.special.execute(None, "tee") with pytest.raises(OSError): with tempfile.NamedTemporaryFile() as f: os.chmod(f.name, stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH) mycli.packages.special.execute(None, f"tee {f.name}") @dbtest @pytest.mark.skipif(os.name == "nt", reason="Bug: fails on Windows, needs fixing, singleton of FQ not working right") def test_favorite_query(): with db_connection().cursor() as cur: query = 'select "✔"' mycli.packages.special.execute(cur, f"\\fs check {query}") assert next(mycli.packages.special.execute(cur, "\\f check"))[0] == "> " + query def test_once_command(): with pytest.raises(TypeError): mycli.packages.special.execute(None, "\\once") with pytest.raises(OSError): mycli.packages.special.execute(None, "\\once /proc/access-denied") mycli.packages.special.write_once("hello world") # write without file set # keep Windows from locking the file with delete=False with tempfile.NamedTemporaryFile(delete=False) as f: mycli.packages.special.execute(None, "\\once " + f.name) mycli.packages.special.write_once("hello world") if os.name == "nt": assert f.read() == b"hello world\r\n" else: assert f.read() == b"hello world\n" mycli.packages.special.execute(None, "\\once -o " + f.name) mycli.packages.special.write_once("hello world line 1") mycli.packages.special.write_once("hello world line 2") f.seek(0) if os.name == "nt": assert f.read() == b"hello world line 1\r\nhello world line 2\r\n" else: assert f.read() == b"hello world line 1\nhello world line 2\n" # delete=False means we should try to clean up try: if os.path.exists(f.name): os.remove(f.name) except Exception as e: print(f"An error occurred while attempting to delete the file: {e}") def test_pipe_once_command(): with pytest.raises(IOError): mycli.packages.special.execute(None, "\\pipe_once") with pytest.raises(OSError): mycli.packages.special.execute(None, "\\pipe_once /proc/access-denied") mycli.packages.special.write_pipe_once("select 1") mycli.packages.special.flush_pipe_once_if_written(None) if os.name == "nt": mycli.packages.special.execute(None, '\\pipe_once python -c "import sys; print(len(sys.stdin.read().strip()))"') mycli.packages.special.write_once("hello world") mycli.packages.special.flush_pipe_once_if_written(None) else: with tempfile.NamedTemporaryFile() as f: mycli.packages.special.execute(None, "\\pipe_once tee " + f.name) mycli.packages.special.write_pipe_once("hello world") mycli.packages.special.flush_pipe_once_if_written(None) f.seek(0) assert f.read() == b"hello world\n" def test_parseargfile(): """Test that parseargfile expands the user directory.""" expected = (os.path.join(os.path.expanduser("~"), "filename"), "a") if os.name == "nt": assert expected == mycli.packages.special.iocommands.parseargfile("~\\filename") else: assert expected == mycli.packages.special.iocommands.parseargfile("~/filename") expected = (os.path.join(os.path.expanduser("~"), "filename"), "w") if os.name == "nt": assert expected == mycli.packages.special.iocommands.parseargfile("-o ~\\filename") else: assert expected == mycli.packages.special.iocommands.parseargfile("-o ~/filename") def test_parseargfile_no_file(): """Test that parseargfile raises a TypeError if there is no filename.""" with pytest.raises(TypeError): mycli.packages.special.iocommands.parseargfile("") with pytest.raises(TypeError): mycli.packages.special.iocommands.parseargfile("-o ") @dbtest def test_watch_query_iteration(): """Test that a single iteration of the result of `watch_query` executes the desired query and returns the given results.""" expected_value = "1" query = f"SELECT {expected_value}" expected_title = f"> {query}" with db_connection().cursor() as cur: result = next(mycli.packages.special.iocommands.watch_query(arg=query, cur=cur)) assert result[0] == expected_title assert result[2][0] == expected_value @dbtest @pytest.mark.skipif(os.name == "nt", reason="Bug: Win handles this differently. May need to refactor watch_query to work for Win") def test_watch_query_full(): """Test that `watch_query`: * Returns the expected results. * Executes the defined times inside the given interval, in this case with a 0.3 seconds wait, it should execute 4 times inside a 1 seconds interval. * Stops at Ctrl-C """ watch_seconds = 0.3 wait_interval = 1 expected_value = "1" query = f"SELECT {expected_value}" expected_title = f"> {query}" expected_results = [4, 5, 6, 7] # Python 3.14 is skipping ahead to 6 or 7 ctrl_c_process = send_ctrl_c(wait_interval) with db_connection().cursor() as cur: results = list(mycli.packages.special.iocommands.watch_query(arg=f"{watch_seconds} {query}", cur=cur)) ctrl_c_process.join(1) assert len(results) in expected_results for result in results: assert result[0] == expected_title assert result[2][0] == expected_value @dbtest @patch("click.clear") def test_watch_query_clear(clear_mock): """Test that the screen is cleared with the -c flag of `watch` command before execute the query.""" with db_connection().cursor() as cur: watch_gen = mycli.packages.special.iocommands.watch_query(arg="0.1 -c select 1;", cur=cur) assert not clear_mock.called next(watch_gen) assert clear_mock.called clear_mock.reset_mock() next(watch_gen) assert clear_mock.called clear_mock.reset_mock() @dbtest def test_watch_query_bad_arguments(): """Test different incorrect combinations of arguments for `watch` command.""" watch_query = mycli.packages.special.iocommands.watch_query with db_connection().cursor() as cur: with pytest.raises(ProgrammingError): next(watch_query("a select 1;", cur=cur)) with pytest.raises(ProgrammingError): next(watch_query("-a select 1;", cur=cur)) with pytest.raises(ProgrammingError): next(watch_query("1 -a select 1;", cur=cur)) with pytest.raises(ProgrammingError): next(watch_query("-c -a select 1;", cur=cur)) @dbtest @patch("click.clear") def test_watch_query_interval_clear(clear_mock): """Test `watch` command with interval and clear flag.""" def test_asserts(gen): clear_mock.reset_mock() start = time() next(gen) assert clear_mock.called next(gen) exec_time = time() - start assert exec_time > seconds and exec_time < (seconds + seconds) seconds = 1.0 watch_query = mycli.packages.special.iocommands.watch_query with db_connection().cursor() as cur: test_asserts(watch_query(f"{seconds} -c select 1;", cur=cur)) test_asserts(watch_query(f"-c {seconds} select 1;", cur=cur)) def test_split_sql_by_delimiter(): for delimiter_str in (";", "$", "😀"): mycli.packages.special.set_delimiter(delimiter_str) sql_input = f"select 1{delimiter_str} select \ufffc2" queries = ("select 1", "select \ufffc2") for query, parsed_query in zip(queries, mycli.packages.special.split_queries(sql_input)): assert query == parsed_query def test_switch_delimiter_within_query(): mycli.packages.special.set_delimiter(";") sql_input = "select 1; delimiter $$ select 2 $$ select 3 $$" queries = ("select 1", "delimiter $$ select 2 $$ select 3 $$", "select 2", "select 3") for query, parsed_query in zip(queries, mycli.packages.special.split_queries(sql_input)): assert query == parsed_query def test_set_delimiter(): for delim in ("foo", "bar"): mycli.packages.special.set_delimiter(delim) assert mycli.packages.special.get_current_delimiter() == delim def teardown_function(): mycli.packages.special.set_delimiter(";") ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/test_sqlexecute.py0000644000175100017510000002447015101406164017137 0ustar00runnerrunner# type: ignore import os import pymysql import pytest from mycli.sqlexecute import ServerInfo, ServerSpecies from test.utils import dbtest, is_expanded_output, run, set_expanded_output def assert_result_equal(result, title=None, rows=None, headers=None, status=None, auto_status=True, assert_contains=False): """Assert that an sqlexecute.run() result matches the expected values.""" if status is None and auto_status and rows: status = f"{len(rows)} row{'s' if len(rows) > 1 else ''} in set" fields = {"title": title, "rows": rows, "headers": headers, "status": status} if assert_contains: # Do a loose match on the results using the *in* operator. for key, field in fields.items(): if field: assert field in result[0][key] else: # Do an exact match on the fields. assert result == [fields] @dbtest def test_conn(executor): run(executor, """create table test(a text)""") run(executor, """insert into test values('abc')""") results = run(executor, """select * from test""") assert_result_equal(results, headers=["a"], rows=[("abc",)]) @dbtest def test_bools(executor): run(executor, """create table test(a boolean)""") run(executor, """insert into test values(True)""") results = run(executor, """select * from test""") assert_result_equal(results, headers=["a"], rows=[(1,)]) @dbtest def test_binary(executor): run(executor, """create table bt(geom linestring NOT NULL)""") run(executor, "INSERT INTO bt VALUES (ST_GeomFromText('LINESTRING(116.37604 39.73979,116.375 39.73965)'));") results = run(executor, """select * from bt""") geom = ( b"\x00\x00\x00\x00\x01\x02\x00\x00\x00\x02\x00\x00\x009\x7f\x13\n" b"\x11\x18]@4\xf4Op\xb1\xdeC@\x00\x00\x00\x00\x00\x18]@B>\xe8\xd9" b"\xac\xdeC@" ) assert_result_equal(results, headers=["geom"], rows=[(geom,)]) @dbtest def test_table_and_columns_query(executor): run(executor, "create table a(x text, y text)") run(executor, "create table b(z text)") assert set(executor.tables()) == {("a",), ("b",)} assert set(executor.table_columns()) == {("a", "x"), ("a", "y"), ("b", "z")} @dbtest def test_database_list(executor): databases = executor.databases() assert "mycli_test_db" in databases @dbtest def test_invalid_syntax(executor): with pytest.raises(pymysql.ProgrammingError) as excinfo: run(executor, "invalid syntax!") assert "You have an error in your SQL syntax;" in str(excinfo.value) @dbtest def test_invalid_column_name(executor): with pytest.raises(pymysql.err.OperationalError) as excinfo: run(executor, "select invalid command") assert "Unknown column 'invalid' in 'field list'" in str(excinfo.value) @dbtest def test_unicode_support_in_output(executor): run(executor, "create table unicodechars(t text)") run(executor, "insert into unicodechars (t) values ('é')") # See issue #24, this raises an exception without proper handling results = run(executor, "select * from unicodechars") assert_result_equal(results, headers=["t"], rows=[("é",)]) @dbtest def test_multiple_queries_same_line(executor): results = run(executor, "select 'foo'; select 'bar'") expected = [ {"title": None, "headers": ["foo"], "rows": [("foo",)], "status": "1 row in set"}, {"title": None, "headers": ["bar"], "rows": [("bar",)], "status": "1 row in set"}, ] assert expected == results @dbtest def test_multiple_queries_same_line_syntaxerror(executor): with pytest.raises(pymysql.ProgrammingError) as excinfo: run(executor, "select 'foo'; invalid syntax") assert "You have an error in your SQL syntax;" in str(excinfo.value) @dbtest @pytest.mark.skipif(os.name == "nt", reason="Bug: fails on Windows, needs fixing, singleton of FQ not working right") def test_favorite_query(executor): set_expanded_output(False) run(executor, "create table test(a text)") run(executor, "insert into test values('abc')") run(executor, "insert into test values('def')") results = run(executor, "\\fs test-a select * from test where a like 'a%'") assert_result_equal(results, status="Saved.") results = run(executor, "\\f test-a") assert_result_equal(results, title="> select * from test where a like 'a%'", headers=["a"], rows=[("abc",)], auto_status=False) results = run(executor, "\\fd test-a") assert_result_equal(results, status="test-a: Deleted.") @dbtest @pytest.mark.skipif(os.name == "nt", reason="Bug: fails on Windows, needs fixing, singleton of FQ not working right") def test_favorite_query_multiple_statement(executor): set_expanded_output(False) run(executor, "create table test(a text)") run(executor, "insert into test values('abc')") run(executor, "insert into test values('def')") results = run(executor, "\\fs test-ad select * from test where a like 'a%'; select * from test where a like 'd%'") assert_result_equal(results, status="Saved.") results = run(executor, "\\f test-ad") expected = [ {"title": "> select * from test where a like 'a%'", "headers": ["a"], "rows": [("abc",)], "status": None}, {"title": "> select * from test where a like 'd%'", "headers": ["a"], "rows": [("def",)], "status": None}, ] assert expected == results results = run(executor, "\\fd test-ad") assert_result_equal(results, status="test-ad: Deleted.") @dbtest @pytest.mark.skipif(os.name == "nt", reason="Bug: fails on Windows, needs fixing, singleton of FQ not working right") def test_favorite_query_expanded_output(executor): set_expanded_output(False) run(executor, """create table test(a text)""") run(executor, """insert into test values('abc')""") results = run(executor, "\\fs test-ae select * from test") assert_result_equal(results, status="Saved.") results = run(executor, "\\f test-ae \\G") assert is_expanded_output() is True assert_result_equal(results, title="> select * from test", headers=["a"], rows=[("abc",)], auto_status=False) set_expanded_output(False) results = run(executor, "\\fd test-ae") assert_result_equal(results, status="test-ae: Deleted.") @dbtest def test_collapsed_output_special_command(executor): set_expanded_output(True) run(executor, "select 1\\g") assert is_expanded_output() is False @dbtest def test_special_command(executor): results = run(executor, "\\?") assert_result_equal(results, rows=("quit", "\\q", "Quit."), headers="Command", assert_contains=True, auto_status=False) @dbtest def test_cd_command_without_a_folder_name(executor): results = run(executor, "system cd") assert_result_equal(results, status="No folder name was provided.") @dbtest def test_system_command_not_found(executor): results = run(executor, "system xyz") if os.name == "nt": assert_result_equal(results, status="OSError: The system cannot find the file specified", assert_contains=True) else: assert_result_equal(results, status="OSError: No such file or directory", assert_contains=True) @dbtest def test_system_command_output(executor): eol = os.linesep test_dir = os.path.abspath(os.path.dirname(__file__)) test_file_path = os.path.join(test_dir, "test.txt") results = run(executor, f"system cat {test_file_path}") assert_result_equal(results, status=f"mycli rocks!{eol}") @dbtest def test_cd_command_current_dir(executor): test_path = os.path.abspath(os.path.dirname(__file__)) run(executor, f"system cd {test_path}") assert os.getcwd() == test_path @dbtest def test_unicode_support(executor): results = run(executor, "SELECT '日本語' AS japanese;") assert_result_equal(results, headers=["japanese"], rows=[("日本語",)]) @dbtest def test_timestamp_null(executor): run(executor, """create table ts_null(a timestamp null)""") run(executor, """insert into ts_null values(null)""") results = run(executor, """select * from ts_null""") assert_result_equal(results, headers=["a"], rows=[(None,)]) @dbtest def test_datetime_null(executor): run(executor, """create table dt_null(a datetime null)""") run(executor, """insert into dt_null values(null)""") results = run(executor, """select * from dt_null""") assert_result_equal(results, headers=["a"], rows=[(None,)]) @dbtest def test_date_null(executor): run(executor, """create table date_null(a date null)""") run(executor, """insert into date_null values(null)""") results = run(executor, """select * from date_null""") assert_result_equal(results, headers=["a"], rows=[(None,)]) @dbtest def test_time_null(executor): run(executor, """create table time_null(a time null)""") run(executor, """insert into time_null values(null)""") results = run(executor, """select * from time_null""") assert_result_equal(results, headers=["a"], rows=[(None,)]) @dbtest def test_multiple_results(executor): query = """CREATE PROCEDURE dmtest() BEGIN SELECT 1; SELECT 2; END""" executor.conn.cursor().execute(query) results = run(executor, "call dmtest;") expected = [ {"title": None, "rows": [(1,)], "headers": ["1"], "status": "1 row in set"}, {"title": None, "rows": [(2,)], "headers": ["2"], "status": "1 row in set"}, ] assert results == expected @pytest.mark.parametrize( "version_string, species, parsed_version_string, version", ( ("5.7.25-TiDB-v6.1.0", "TiDB", "6.1.0", 60100), ("8.0.11-TiDB-v7.2.0-alpha-69-g96e9e68daa", "TiDB", "7.2.0", 70200), ("5.7.32-35", "Percona", "5.7.32", 50732), ("5.7.32-0ubuntu0.18.04.1", "MySQL", "5.7.32", 50732), ("10.5.8-MariaDB-1:10.5.8+maria~focal", "MariaDB", "10.5.8", 100508), ("5.5.5-10.5.8-MariaDB-1:10.5.8+maria~focal", "MariaDB", "10.5.8", 100508), ("5.0.16-pro-nt-log", "MySQL", "5.0.16", 50016), ("5.1.5a-alpha", "MySQL", "5.1.5", 50105), ("unexpected version string", None, "", 0), ("", None, "", 0), (None, None, "", 0), ), ) def test_version_parsing(version_string, species, parsed_version_string, version): server_info = ServerInfo.from_version_string(version_string) assert (server_info.species and server_info.species.name) == species or ServerSpecies.MySQL assert server_info.version_str == parsed_version_string assert server_info.version == version ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/test_tabular_output.py0000644000175100017510000001060515101406164020022 0ustar00runnerrunner# type: ignore """Test the sql output adapter.""" from textwrap import dedent from pymysql.constants import FIELD_TYPE import pytest from mycli.main import MyCli from test.utils import HOST, PASSWORD, PORT, USER, dbtest @pytest.fixture def mycli(): cli = MyCli() cli.connect(None, USER, PASSWORD, HOST, PORT, None, init_command=None) return cli @dbtest def test_sql_output(mycli): """Test the sql output adapter.""" headers = ["letters", "number", "optional", "float", "binary"] class FakeCursor: def __init__(self): self.data = [("abc", 1, None, 10.0, b"\xaa"), ("d", 456, "1", 0.5, b"\xaa\xbb")] self.description = [ (None, FIELD_TYPE.VARCHAR), (None, FIELD_TYPE.LONG), (None, FIELD_TYPE.LONG), (None, FIELD_TYPE.FLOAT), (None, FIELD_TYPE.BLOB), ] def __iter__(self): return self def __next__(self): if self.data: return self.data.pop(0) else: raise StopIteration() def description(self): return self.description # Test sql-update output format assert list(mycli.change_table_format("sql-update")) == [(None, None, None, "Changed table format to sql-update")] mycli.main_formatter.query = "" mycli.redirect_formatter.query = "" output = mycli.format_output(None, FakeCursor(), headers, False, False) actual = "\n".join(output) assert actual == dedent("""\ UPDATE `DUAL` SET `number` = 1 , `optional` = NULL , `float` = 10.0e0 , `binary` = X'aa' WHERE `letters` = 'abc'; UPDATE `DUAL` SET `number` = 456 , `optional` = '1' , `float` = 0.5e0 , `binary` = X'aabb' WHERE `letters` = 'd';""") # Test sql-update-2 output format assert list(mycli.change_table_format("sql-update-2")) == [(None, None, None, "Changed table format to sql-update-2")] mycli.main_formatter.query = "" mycli.redirect_formatter.query = "" output = mycli.format_output(None, FakeCursor(), headers, False, False) assert "\n".join(output) == dedent("""\ UPDATE `DUAL` SET `optional` = NULL , `float` = 10.0e0 , `binary` = X'aa' WHERE `letters` = 'abc' AND `number` = 1; UPDATE `DUAL` SET `optional` = '1' , `float` = 0.5e0 , `binary` = X'aabb' WHERE `letters` = 'd' AND `number` = 456;""") # Test sql-insert output format (without table name) assert list(mycli.change_table_format("sql-insert")) == [(None, None, None, "Changed table format to sql-insert")] mycli.main_formatter.query = "" mycli.redirect_formatter.query = "" output = mycli.format_output(None, FakeCursor(), headers, False, False) assert "\n".join(output) == dedent("""\ INSERT INTO `DUAL` (`letters`, `number`, `optional`, `float`, `binary`) VALUES ('abc', 1, NULL, 10.0e0, X'aa') , ('d', 456, '1', 0.5e0, X'aabb') ;""") # Test sql-insert output format (with table name) assert list(mycli.change_table_format("sql-insert")) == [(None, None, None, "Changed table format to sql-insert")] mycli.main_formatter.query = "SELECT * FROM `table`" mycli.redirect_formatter.query = "SELECT * FROM `table`" output = mycli.format_output(None, FakeCursor(), headers, False, False) assert "\n".join(output) == dedent("""\ INSERT INTO table (`letters`, `number`, `optional`, `float`, `binary`) VALUES ('abc', 1, NULL, 10.0e0, X'aa') , ('d', 456, '1', 0.5e0, X'aabb') ;""") # Test sql-insert output format (with database + table name) assert list(mycli.change_table_format("sql-insert")) == [(None, None, None, "Changed table format to sql-insert")] mycli.main_formatter.query = "SELECT * FROM `database`.`table`" mycli.redirect_formatter.query = "SELECT * FROM `database`.`table`" output = mycli.format_output(None, FakeCursor(), headers, False, False) assert "\n".join(output) == dedent("""\ INSERT INTO database.table (`letters`, `number`, `optional`, `float`, `binary`) VALUES ('abc', 1, NULL, 10.0e0, X'aa') , ('d', 456, '1', 0.5e0, X'aabb') ;""") ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/test/utils.py0000644000175100017510000000465315101406164015057 0ustar00runnerrunner# type: ignore import multiprocessing import os import platform import signal import time import pymysql import pytest from mycli.main import special PASSWORD = os.getenv("PYTEST_PASSWORD") USER = os.getenv("PYTEST_USER", "root") HOST = os.getenv("PYTEST_HOST", "localhost") PORT = int(os.getenv("PYTEST_PORT", "3306")) CHARSET = os.getenv("PYTEST_CHARSET", "utf8") SSH_USER = os.getenv("PYTEST_SSH_USER", None) SSH_HOST = os.getenv("PYTEST_SSH_HOST", None) SSH_PORT = int(os.getenv("PYTEST_SSH_PORT", "22")) def db_connection(dbname=None): conn = pymysql.connect(user=USER, host=HOST, port=PORT, database=dbname, password=PASSWORD, charset=CHARSET, local_infile=False) conn.autocommit = True return conn try: db_connection() CAN_CONNECT_TO_DB = True except Exception: CAN_CONNECT_TO_DB = False dbtest = pytest.mark.skipif(not CAN_CONNECT_TO_DB, reason="Need a mysql instance at localhost accessible by user 'root'") def create_db(dbname): with db_connection().cursor() as cur: try: cur.execute("""DROP DATABASE IF EXISTS mycli_test_db""") cur.execute("""CREATE DATABASE mycli_test_db""") except Exception: pass def run(executor, sql, rows_as_list=True): """Return string output for the sql to be run.""" result = [] for title, rows, headers, status in executor.run(sql): rows = list(rows) if (rows_as_list and rows) else rows result.append({"title": title, "rows": rows, "headers": headers, "status": status}) return result def set_expanded_output(is_expanded): """Pass-through for the tests.""" return special.set_expanded_output(is_expanded) def is_expanded_output(): """Pass-through for the tests.""" return special.is_expanded_output() def send_ctrl_c_to_pid(pid, wait_seconds): """Sends a Ctrl-C like signal to the given `pid` after `wait_seconds` seconds.""" time.sleep(wait_seconds) system_name = platform.system() if system_name == "Windows": os.kill(pid, signal.CTRL_C_EVENT) else: os.kill(pid, signal.SIGINT) def send_ctrl_c(wait_seconds): """Create a process that sends a Ctrl-C like signal to the current process after `wait_seconds` seconds. Returns the `multiprocessing.Process` created. """ ctrl_c_process = multiprocessing.Process(target=send_ctrl_c_to_pid, args=(os.getpid(), wait_seconds)) ctrl_c_process.start() return ctrl_c_process ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1762004084.0 mycli-1.41.0/tox.ini0000644000175100017510000000060515101406164013672 0ustar00runnerrunner[tox] envlist = py [testenv] skip_install = true deps = uv passenv = PYTEST_HOST PYTEST_USER PYTEST_PASSWORD PYTEST_PORT PYTEST_CHARSET commands = uv pip install -e .[dev,ssh] coverage run -m pytest -v test coverage report -m behave test/features [testenv:style] skip_install = true deps = ruff commands = ruff check ruff format --diff