mycli 2.22.0__tar.gz → 2.24.0__tar.gz

{mycli-2.22.0 → mycli-2.24.0}/.github/workflows/publish.yml

@@ -304,6 +304,7 @@ jobs:
       uses: docker/build-push-action@53b7df96c91f9c12dcc8a07bcb9ccacbed38856a # v7.3.0
       with:
         context: .
+        file: docker/Dockerfile
         push: true
         tags: ${{ steps.meta.outputs.tags }}
         labels: ${{ steps.meta.outputs.labels }}

{mycli-2.22.0/mycli.egg-info → mycli-2.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycli
-Version: 2.22.0
+Version: 2.24.0
 Summary: Rich MySQL terminal client with autocompletion, syntax highlighting, and dataframes
 Author: Mycli Core Team
 License-Expression: BSD-3-Clause
@@ -238,7 +238,7 @@ sudo dnf install mycli fzf python-pygments
 The images on Dockerhub are out of date.  ghcr.io is preferred.  Example:
 
 ```
-docker run -it ghcr.io/dbcli/mycli:latest mycli --help
+docker run --pull=always -it ghcr.io/dbcli/mycli:latest
 ```
 
 ### Windows

{mycli-2.22.0 → mycli-2.24.0}/README.md

@@ -166,7 +166,7 @@ sudo dnf install mycli fzf python-pygments
 The images on Dockerhub are out of date.  ghcr.io is preferred.  Example:
 
 ```
-docker run -it ghcr.io/dbcli/mycli:latest mycli --help
+docker run --pull=always -it ghcr.io/dbcli/mycli:latest
 ```
 
 ### Windows

{mycli-2.22.0 → mycli-2.24.0}/changelog.md

@@ -1,3 +1,34 @@
+2.24.0 (2026/09/12)
+==============
+
+Features
+--------
+* Preserve the query as metadata when saving to Parquet with `.>`.
+* Make completion candidate match order configurable.
+* Make approximate-matching completion thresholds configurable.
+* Make regex matching completion thresholds configurable.
+* Make completion-candidate sorting tiebreaker configurable.
+* Add a `\b` prompt format string to show transaction status.
+
+
+2.23.0 (2026/09/09)
+==============
+
+Features
+--------
+* Include a MariaDB server and example data in the Docker image.
+
+
+Bug Fixes
+--------
+* Tokenize leading `/` and `\` as symbol names for better highlighting.
+
+
+Documentation
+--------
+* Add `--pull=always` to documented `docker run` command.
+
+
 2.22.0 (2026/09/09)
 ==============
 

{mycli-2.22.0 → mycli-2.24.0/docker}/Dockerfile

@@ -5,6 +5,7 @@ ENV DEBIAN_FRONTEND=noninteractive
 RUN apt-get update -qq && \
     apt-get install -y --no-install-recommends --no-install-suggests -qq \
     fzf \
+    mariadb-server \
     && \
     apt-get clean autoclean && \
     apt-get autoremove --yes && \
@@ -12,6 +13,14 @@ RUN apt-get update -qq && \
 
 COPY . /app
 
+RUN service mariadb restart && \
+    cd /app/docker/resources && \
+    gunzip -c test_db-1.0.7.tar.gz | tar -xf - && \
+    cd test_db && \
+    mariadb < employees.sql && \
+    cd .. && \
+    rm -r -- ./test_db
+
 RUN cd /app && pip install --root-user-action=ignore -e .[llm,dataframe]
 
-CMD ["mycli", "--help"]
+CMD ["sh", "-c", "service mariadb start && mycli --database employees"]

{mycli-2.22.0 → mycli-2.24.0}/mycli/client.py

@@ -212,7 +212,17 @@ class MyCli(AppStateMixin, OutputMixin, ClientCommandsMixin, ClientConnectionMix
             keyword_casing=keyword_casing,
             indexed_column_suffix=indexed_column_suffix,
             config_property_names=get_config_property_names(self.config),
+            completion_match_order=c['main'].as_list('completion_match_order') if 'completion_match_order' in c['main'] else (),
+            completion_tiebreaker=c['main'].get('completion_tiebreaker', 'frecency') or 'frecency',
+            rapidfuzz_min_length=c['main'].as_int('rapidfuzz_min_length') if c['main'].get('rapidfuzz_min_length') else 4,
+            regex_match_distance=c['main'].as_int('regex_match_distance') if c['main'].get('regex_match_distance') else 3,
+            rapidfuzz_score_cutoff=c['main'].as_float('rapidfuzz_score_cutoff') if c['main'].get('rapidfuzz_score_cutoff') else 75.0,
+            rapidfuzz_length_coverage=c['main'].as_float('rapidfuzz_length_coverage')
+            if c['main'].get('rapidfuzz_length_coverage')
+            else 0.67,
         )
+        for error in self.completer.completion_config_errors:
+            self.echo(error, err=True, fg='red')
         self._completer_lock = threading.Lock()
 
         self.min_completion_trigger = c["main"].as_int("min_completion_trigger")

{mycli-2.22.0 → mycli-2.24.0}/mycli/client_query.py

@@ -60,6 +60,12 @@ class ClientQueryMixin:
                 "indexed_column_suffix": self.completer.indexed_column_suffix,
                 "config_property_names": self.completer.config_property_names,
                 'frecency_provider': self.completer.frecency_provider,
+                'completion_match_order': self.completer.completion_match_order,
+                'completion_tiebreaker': self.completer.completion_tiebreaker,
+                'rapidfuzz_min_length': self.completer.rapidfuzz_min_length,
+                'rapidfuzz_length_coverage': self.completer.rapidfuzz_length_coverage,
+                'rapidfuzz_score_cutoff': self.completer.rapidfuzz_score_cutoff,
+                'regex_match_distance': self.completer.regex_match_distance,
             },
         )
 

{mycli-2.22.0 → mycli-2.24.0}/mycli/lexer.py

@@ -1,6 +1,6 @@
 from pygments.lexer import inherit
 from pygments.lexers.sql import MySqlLexer
-from pygments.token import Keyword
+from pygments.token import Keyword, Name
 
 
 class MyCliLexer(MySqlLexer):
@@ -8,6 +8,7 @@ class MyCliLexer(MySqlLexer):
 
     tokens = {
         "root": [
+            (r'^[/\\]', Name),
             (r"\brepair\b", Keyword),
             (r"\boffset\b", Keyword),
             inherit,

{mycli-2.22.0 → mycli-2.24.0}/mycli/main_modes/repl.py

@@ -43,6 +43,7 @@ from prompt_toolkit.lexers import PygmentsLexer
 from prompt_toolkit.output import ColorDepth
 from prompt_toolkit.shortcuts import CompleteStyle, PromptSession
 import pymysql
+from pymysql.constants.SERVER_STATUS import SERVER_STATUS_IN_TRANS
 from pymysql.cursors import Cursor
 
 import mycli as mycli_package
@@ -343,6 +344,13 @@ def render_prompt_string(
     strings = [x.replace('\\_', ' ') for x in strings]
 
     checker_string = ' '.join(strings)
+    if r'\b' in checker_string:
+        connection = getattr(sqlexecute, 'conn', None)
+        if connection:
+            connection.ping(reconnect=False)
+        server_status = getattr(connection, 'server_status', 0) or 0
+        transaction_indicator = '[TX]' if server_status & SERVER_STATUS_IN_TRANS else ''
+        strings = [x.replace(r'\b', transaction_indicator) for x in strings]
     if r'\e' in checker_string:
         if mycli.prompt_session:
             edit_mode = mycli.prompt_session.editing_mode.value.lower()
@@ -940,6 +948,7 @@ def _one_iteration(
                     polars_transform,
                     results,
                     polars_pipeline.output_path,
+                    original_query=original_text,
                     image_protocol=mycli.image_protocol,
                     plot_scale_factor=mycli.plot_scale_factor,
                     plot_ppi=mycli.plot_ppi,

{mycli-2.22.0 → mycli-2.24.0}/mycli/myclirc

@@ -9,6 +9,41 @@ show_warnings = False
 # possible completions will be listed.
 smart_completion = True
 
+# Methods to find completion candidates, highest priority first.  Omitted
+# methods follow in the default order; empty uses the default.  Filename
+# and Polars completions retain their own dedicated ordering.
+# * perfect - exact leading match
+# * regex - ordered charater match with limited intervening spans ("rgx" matches "regex")
+# * under_words - like regex but follows underscores ("uw" matches "under_words")
+# * slash_words - like regex but follows slahes ("sw" matches "slash/words")
+# * camel_case - like regex but follows capitalization ("cc" matches "CamelCase")
+# * rapidfuzz - true approximate matching, _ie_ autcorrect
+completion_match_order = perfect, regex, under_words, slash_words, camel_case, rapidfuzz
+
+# Break completion candiate sorting ties by
+# * frecency - history frequency combined with recency, the default
+# * length - shortest first
+# * lexicographic - alphabetical, ignoring case
+completion_tiebreaker = frecency
+
+# Maximum intervening span length between input characters for regex completion
+# candidate matches.  Empty uses the default of 3.  Higher is more liberal, but
+# carries a perforance penalty.
+regex_match_distance = 3
+
+# Minimum input characters before using rapidfuzz approximate matching.
+# Empty uses the default of 4.  Set to 0 or less to remove the minimum.
+rapidfuzz_min_length = 4
+
+# Minimum rapidfuzz candidate length as a fraction of the input length.
+# Empty uses 0.67.  Lower is more liberal.  Set to 0 or less to suppress
+# the length filter.
+rapidfuzz_length_coverage = 0.67
+
+# Minimum rapidfuzz similarity score (0-100).  Lower is more liberal.
+# Empty uses the default of 75.
+rapidfuzz_score_cutoff = 75
+
 # Text appended to indexed column names in the completion menu.  This text is
 # not inserted into the query. Leave empty to disable the marker.  Quote values
 # containing spaces, commas, or comment characters.
@@ -165,6 +200,7 @@ wider_completion_menu = False
 # * \W - number of warnings, or the empty string (requires frequent trips to the server)
 # * \y - uptime in seconds (requires frequent trips to the server)
 # * \Y - uptime in words (requires frequent trips to the server)
+# * \b - "[TX]" when in a transaction, otherwise empty (requires frequent trips to the server)
 # * \A - DSN alias
 # * \n - a newline
 # * \_ - a space

{mycli-2.22.0 → mycli-2.24.0}/mycli/packages/polars_transform.py

@@ -17,6 +17,7 @@ from mycli.types import ImageProtocol, OutputMode
 
 delimiter_command = DelimiterCommand()
 PLOT_FORMATS = ('png', 'pdf', 'svg', 'html')
+PARQUET_QUERY_METADATA_KEY = 'mycli_query'
 
 
 class PolarsTransformError(RuntimeError):
@@ -151,7 +152,7 @@ def _pipeline_operator_indexes(
 
 
 def _parse_output_path(path: str) -> str:
-    if path[0] in ('\'', '"'):
+    if path[0] in ("'", '"'):
         if len(path) < 2 or path[-1] != path[0]:
             raise PolarsTransformError('File save paths must use matching quotes.')
         path = path[1:-1]
@@ -223,6 +224,7 @@ def run_polars_transform(
     results: Iterable[SQLResult],
     output_path: str | None = None,
     *,
+    original_query: str | None = None,
     image_protocol: ImageProtocol = 'none',
     plot_scale_factor: float = 1.0,
     plot_ppi: int = 200,
@@ -278,7 +280,7 @@ def run_polars_transform(
             if not output_path.lower().endswith('.parquet'):
                 raise PolarsTransformError('Polars DataFrame results can only be written to ".parquet" files.')
             try:
-                value.write_parquet(output_path)
+                _write_parquet(value, output_path, original_query or transform.sql)
             except Exception as exc:
                 raise PolarsTransformError(f'Unable to write Parquet file "{output_path}": {type(exc).__name__}: {exc}') from exc
             return SQLResult(status=f'Wrote {len(value)} rows to {output_path}.')
@@ -290,7 +292,7 @@ def run_polars_transform(
                 raise PolarsTransformError('Polars Series results can only be written to ".parquet" files.')
             try:
                 series_dataframe = value.rename(column_name).to_frame()
-                series_dataframe.write_parquet(output_path)
+                _write_parquet(series_dataframe, output_path, original_query or transform.sql)
             except Exception as exc:
                 raise PolarsTransformError(f'Unable to write Parquet file "{output_path}": {type(exc).__name__}: {exc}') from exc
             return SQLResult(status=f'Wrote {len(series_dataframe)} rows to {output_path}.')
@@ -339,3 +341,7 @@ def run_polars_transform(
         return SQLResult()
 
     return SQLResult(status=f'Nothing could be displayed for return type: {type(value)}')
+
+
+def _write_parquet(dataframe: Any, parquet_path: str, original_query: str) -> None:
+    dataframe.write_parquet(parquet_path, metadata={PARQUET_QUERY_METADATA_KEY: original_query})

{mycli-2.22.0 → mycli-2.24.0}/mycli/sqlcompleter.py

@@ -955,12 +955,40 @@ class SQLCompleter(Completer):
         indexed_column_suffix: str = '*',
         config_property_names: Collection[str] = (),
         frecency_provider: Callable[[], Mapping[str, float]] | None = None,
+        completion_match_order: Collection[str] = (),
+        rapidfuzz_min_length: int = 4,
+        rapidfuzz_length_coverage: float = 0.67,
+        rapidfuzz_score_cutoff: float = 75.0,
+        regex_match_distance: int = 3,
+        completion_tiebreaker: str = 'frecency',
     ) -> None:
         super(self.__class__, self).__init__()
         self.smart_completion = smart_completion
         self.indexed_column_suffix = indexed_column_suffix
         self.config_property_names = tuple(sorted(config_property_names))
         self.frecency_provider = frecency_provider
+        self.rapidfuzz_min_length = max(0, rapidfuzz_min_length)
+        self.rapidfuzz_length_coverage = max(0.0, rapidfuzz_length_coverage)
+        self.rapidfuzz_score_cutoff = max(0.0, min(100.0, rapidfuzz_score_cutoff))
+        self.regex_match_distance = max(0, regex_match_distance)
+        self.completion_config_errors: list[str] = []
+        self.completion_tiebreaker: Literal['frecency', 'length', 'lexicographic'] = 'frecency'
+        tiebreaker = completion_tiebreaker.strip().lower()
+        if tiebreaker == 'length':
+            self.completion_tiebreaker = 'length'
+        elif tiebreaker == 'lexicographic':
+            self.completion_tiebreaker = 'lexicographic'
+        elif tiebreaker not in ('', 'frecency'):
+            self.completion_config_errors.append('Invalid completion_tiebreaker; using frecency.')
+        default_order = tuple(category.name.lower() for category in Fuzziness)
+        order = tuple(name.strip().lower() for name in completion_match_order if name.strip())
+        if len(set(order)) != len(order) or any(name not in default_order for name in order):
+            self.completion_config_errors.append('Invalid completion_match_order; using the default order.')
+            order = ()
+        self.completion_match_order = order + tuple(name for name in default_order if name not in order)
+        self._match_priorities: dict[int, int] = {
+            Fuzziness[name.upper()]: priority for priority, name in enumerate(self.completion_match_order)
+        }
         self.reserved_words = set()
         for x in self.keywords:
             self.reserved_words.update(x.split())
@@ -1313,16 +1341,17 @@ class SQLCompleter(Completer):
         under_words_text: list[str],
         case_words_text: list[str],
     ) -> int | None:
-        if pattern.search(item.lower()):
-            return Fuzziness.REGEX
-
-        under_words_item = [x for x in item.lower().split('_') if x]
-        if self.word_parts_match(under_words_text, under_words_item):
-            return Fuzziness.UNDER_WORDS
-
-        case_words_item = re.split(_CASE_CHANGE_PAT, item)
-        if self.word_parts_match(case_words_text, case_words_item):
-            return Fuzziness.CAMEL_CASE
+        for name in self.completion_match_order:
+            if name == 'regex' and pattern.search(item.lower()):
+                return Fuzziness.REGEX
+            if name == 'under_words':
+                under_words_item = [x for x in item.lower().split('_') if x]
+                if self.word_parts_match(under_words_text, under_words_item):
+                    return Fuzziness.UNDER_WORDS
+            if name == 'camel_case':
+                case_words_item = re.split(_CASE_CHANGE_PAT, item)
+                if self.word_parts_match(case_words_text, case_words_item):
+                    return Fuzziness.CAMEL_CASE
 
         return None
 
@@ -1333,7 +1362,7 @@ class SQLCompleter(Completer):
         collection: Collection[Any],
     ) -> list[tuple[str, int]]:
         completions: list[tuple[str, int]] = []
-        regex = '.{0,3}?'.join(map(re.escape, text))
+        regex = f'.{{0,{self.regex_match_distance}}}?'.join(map(re.escape, text))
         pattern = re.compile(f'({regex})')
         under_words_text = [x for x in text.split('_') if x]
         case_words_text = re.split(_CASE_CHANGE_PAT, last)
@@ -1343,7 +1372,7 @@ class SQLCompleter(Completer):
             if fuzziness is not None:
                 completions.append((item, fuzziness))
 
-        if len(text) >= 4:
+        if len(text) >= self.rapidfuzz_min_length:
             rapidfuzz_matches = rapidfuzz.process.extract(
                 text,
                 collection,
@@ -1352,12 +1381,18 @@ class SQLCompleter(Completer):
                 # because underscores are valuable info
                 processor=rapidfuzz.utils.default_process,
                 limit=20,
-                score_cutoff=75,
+                score_cutoff=self.rapidfuzz_score_cutoff,
             )
-            existing = {c[0] for c in completions}
+            existing = {c[0]: index for index, c in enumerate(completions)}
             for item, _score, _type in rapidfuzz_matches:
-                if len(item) < len(text) / 1.5 or item in existing:
+                if len(item) < len(text) * self.rapidfuzz_length_coverage:
                     continue
+                if item in existing:
+                    index = existing[item]
+                    if self._match_priorities[Fuzziness.RAPIDFUZZ] < self._match_priorities[completions[index][1]]:
+                        completions[index] = (item, Fuzziness.RAPIDFUZZ)
+                    continue
+                existing[item] = len(completions)
                 completions.append((item, Fuzziness.RAPIDFUZZ))
 
         return completions
@@ -1457,7 +1492,14 @@ class SQLCompleter(Completer):
         last_for_len = last_word(word_before_cursor, include="most_punctuations")
         text_for_len = last_for_len.lower()
         path_for_len = word_before_cursor
-        frecency = self.frecency_provider() if self.frecency_provider is not None else {}
+        frecency = self.frecency_provider() if self.completion_tiebreaker == 'frecency' and self.frecency_provider is not None else {}
+
+        def tiebreaker_key(candidate: str) -> tuple[float, str]:
+            if self.completion_tiebreaker == 'length':
+                return (len(candidate), '')
+            if self.completion_tiebreaker == 'lexicographic':
+                return (0, candidate.casefold())
+            return (-frecency_score(candidate, frecency) if frecency else 0.0, '')
 
         if smart_completion is None:
             smart_completion = self.smart_completion
@@ -1472,8 +1514,8 @@ class SQLCompleter(Completer):
                 fuzzy=False,
                 text_before_cursor=document.text_before_cursor,
             )
-            if frecency:
-                matches = sorted(matches, key=lambda item: -frecency_score(item[0], frecency))
+            if frecency or self.completion_tiebreaker != 'frecency':
+                matches = sorted(matches, key=lambda item: tiebreaker_key(item[0]))
             return (Completion(x[0], -len(text_for_len)) for x in matches)
 
         completions: list[tuple[str, int, int]] = []
@@ -1835,18 +1877,16 @@ class SQLCompleter(Completer):
                     ]
                     break
 
-        def completion_sort_key(item: tuple[str, int, int], text_for_len: str):
+        def completion_sort_key(item: tuple[str, int, int], text_for_len: str) -> tuple[int, int, tuple[float, str], int]:
             candidate, fuzziness, rank = item
-            candidate_frecency = frecency_score(candidate, frecency) if frecency else 0.0
+            tiebreaker = tiebreaker_key(candidate)
             if not text_for_len:
-                # Sort by the rank (the order of the completion type), then frecency.
-                return (0, rank, -candidate_frecency, 0)
+                return (0, rank, tiebreaker, 0)
             elif candidate.lower().startswith(text_for_len):
-                # Direct prefix matches are equally relevant; prefer frecency before length.
-                return (0, 0, -candidate_frecency, -1000 + len(candidate))
-            # Sort by fuzziness, rank, and frecency.
-            # todo add alpha here, or original order?
-            return (fuzziness, rank, -candidate_frecency, 0)
+                # Preserve the shorter-prefix fallback for equal frecency scores.
+                length = -1000 + len(candidate) if self.completion_tiebreaker == 'frecency' else 0
+                return (0, 0, tiebreaker, length)
+            return (self._match_priorities[fuzziness], rank, tiebreaker, 0)
 
         if rigid_sort:
             uniq_completions_str = dict.fromkeys(x[0] for x in completions)

{mycli-2.22.0 → mycli-2.24.0/mycli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycli
-Version: 2.22.0
+Version: 2.24.0
 Summary: Rich MySQL terminal client with autocompletion, syntax highlighting, and dataframes
 Author: Mycli Core Team
 License-Expression: BSD-3-Clause
@@ -238,7 +238,7 @@ sudo dnf install mycli fzf python-pygments
 The images on Dockerhub are out of date.  ghcr.io is preferred.  Example:
 
 ```
-docker run -it ghcr.io/dbcli/mycli:latest mycli --help
+docker run --pull=always -it ghcr.io/dbcli/mycli:latest
 ```
 
 ### Windows

{mycli-2.22.0 → mycli-2.24.0}/mycli.egg-info/SOURCES.txt

@@ -3,7 +3,6 @@
 AGENTS.md
 AUTHORS.rst
 CONTRIBUTING.md
-Dockerfile
 LICENSE.txt
 MANIFEST.in
 README.md
@@ -24,6 +23,8 @@ doc/transforms.md
 doc/screenshots/main.gif
 doc/screenshots/tables.png
 doc/screenshots/total_histogram.png
+docker/Dockerfile
+docker/resources/test_db-1.0.7.tar.gz
 mycli/AUTHORS
 mycli/SPONSORS
 mycli/TIPS

{mycli-2.22.0 → mycli-2.24.0}/mycli.egg-info/scm_file_list.json

@@ -13,7 +13,6 @@
     "AGENTS.md",
     "AUTHORS.rst",
     "CONTRIBUTING.md",
-    "Dockerfile",
     "LICENSE.txt",
     "MANIFEST.in",
     "README.md",
@@ -25,6 +24,8 @@
     "doc/screenshots/tables.png",
     "doc/screenshots/total_histogram.png",
     "doc/transforms.md",
+    "docker/Dockerfile",
+    "docker/resources/test_db-1.0.7.tar.gz",
     "mycli/AUTHORS",
     "mycli/SPONSORS",
     "mycli/TIPS",

mycli-2.24.0/mycli.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "2.24.0",
+  "distance": 0,
+  "node": "gf969367e7367f166722f1dc45f2dc8480156fb25",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-12"
+}

{mycli-2.22.0 → mycli-2.24.0}/test/myclirc

@@ -9,6 +9,41 @@ show_warnings = False
 # possible completions will be listed.
 smart_completion = True
 
+# Methods to find completion candidates, highest priority first.  Omitted
+# methods follow in the default order; empty uses the default.  Filename
+# and Polars completions retain their own dedicated ordering.
+# * perfect - exact leading match
+# * regex - ordered charater match with limited intervening spans ("rgx" matches "regex")
+# * under_words - like regex but follows underscores ("uw" matches "under_words")
+# * slash_words - like regex but follows slahes ("sw" matches "slash/words")
+# * camel_case - like regex but follows capitalization ("cc" matches "CamelCase")
+# * rapidfuzz - true approximate matching, _ie_ autcorrect
+completion_match_order = perfect, regex, under_words, slash_words, camel_case, rapidfuzz
+
+# Break completion candiate sorting ties by
+# * frecency - history frequency combined with recency, the default
+# * length - shortest first
+# * lexicographic - alphabetical, ignoring case
+completion_tiebreaker = frecency
+
+# Maximum intervening span length between input characters for regex completion
+# candidate matches.  Empty uses the default of 3.  Higher is more liberal, but
+# carries a perforance penalty.
+regex_match_distance = 3
+
+# Minimum input characters before using rapidfuzz approximate matching.
+# Empty uses the default of 4.  Set to 0 or less to remove the minimum.
+rapidfuzz_min_length = 4
+
+# Minimum rapidfuzz candidate length as a fraction of the input length.
+# Empty uses 0.67.  Lower is more liberal.  Set to 0 or less to suppress
+# the length filter.
+rapidfuzz_length_coverage = 0.67
+
+# Minimum rapidfuzz similarity score (0-100).  Lower is more liberal.
+# Empty uses the default of 75.
+rapidfuzz_score_cutoff = 75
+
 # Text appended to indexed column names in the completion menu.  This text is
 # not inserted into the query. Leave empty to disable the marker.  Quote values
 # containing spaces, commas, or comment characters.
@@ -165,6 +200,7 @@ wider_completion_menu = False
 # * \W - number of warnings, or the empty string (requires frequent trips to the server)
 # * \y - uptime in seconds (requires frequent trips to the server)
 # * \Y - uptime in words (requires frequent trips to the server)
+# * \b - "[TX]" when in a transaction, otherwise empty (requires frequent trips to the server)
 # * \A - DSN alias
 # * \n - a newline
 # * \_ - a space

{mycli-2.22.0 → mycli-2.24.0}/test/pytests/test_client.py

@@ -27,6 +27,100 @@ def patch_constructor_side_effects(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setattr(client_module, 'get_mylogin_cnf_path', lambda: None)
 
 
+def test_init_configures_completion_ranking(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    patch_constructor_side_effects(monkeypatch)
+    myclirc = write_myclirc(tmp_path, '[main]\ncompletion_match_order = CAMEL_CASE, under_words\n')
+
+    cli = MyCli(myclirc=myclirc)
+
+    assert cli.completer.completion_match_order == ('camel_case', 'under_words', 'perfect', 'regex', 'slash_words', 'rapidfuzz')
+
+
+@pytest.mark.parametrize(
+    ('value', 'expected'),
+    [(None, 'frecency'), ('', 'frecency'), ('length', 'length'), ('LEXICOGRAPHIC', 'lexicographic'), ('invalid', 'frecency')],
+)
+def test_init_configures_completion_tiebreaker(monkeypatch: pytest.MonkeyPatch, tmp_path: Path, value: str | None, expected: str) -> None:
+    patch_constructor_side_effects(monkeypatch)
+    messages: list[str] = []
+    monkeypatch.setattr(MyCli, 'echo', lambda self, message, **kwargs: messages.append(message))
+    setting = f'completion_tiebreaker = {value}\n' if value is not None else ''
+    cli = MyCli(myclirc=write_myclirc(tmp_path, f'[main]\n{setting}'))
+
+    assert cli.completer.completion_tiebreaker == expected
+    assert messages == (['Invalid completion_tiebreaker; using frecency.'] if value == 'invalid' else [])
+
+
+@pytest.mark.parametrize(('value', 'expected'), [(None, 3), ('', 3), ('5', 5), ('0', 0), ('-1', 0)])
+def test_init_configures_regex_match_distance(monkeypatch: pytest.MonkeyPatch, tmp_path: Path, value: str | None, expected: int) -> None:
+    patch_constructor_side_effects(monkeypatch)
+    setting = f'regex_match_distance = {value}\n' if value is not None else ''
+    myclirc = write_myclirc(tmp_path, f'[main]\n{setting}')
+
+    cli = MyCli(myclirc=myclirc)
+
+    assert cli.completer.regex_match_distance == expected
+
+
+@pytest.mark.parametrize(('value', 'expected'), [(None, 4), ('', 4), ('2', 2), ('0', 0), ('-1', 0)])
+def test_init_configures_rapidfuzz_min_length(monkeypatch: pytest.MonkeyPatch, tmp_path: Path, value: str | None, expected: int) -> None:
+    patch_constructor_side_effects(monkeypatch)
+    setting = f'rapidfuzz_min_length = {value}\n' if value is not None else ''
+    myclirc = write_myclirc(tmp_path, f'[main]\n{setting}')
+
+    cli = MyCli(myclirc=myclirc)
+
+    assert cli.completer.rapidfuzz_min_length == expected
+
+
+@pytest.mark.parametrize(('value', 'expected'), [(None, 0.67), ('', 0.67), ('0.5', 0.5), ('0', 0.0), ('-1', 0.0)])
+def test_init_configures_rapidfuzz_length_coverage(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path, value: str | None, expected: float
+) -> None:
+    patch_constructor_side_effects(monkeypatch)
+    setting = f'rapidfuzz_length_coverage = {value}\n' if value is not None else ''
+    myclirc = write_myclirc(tmp_path, f'[main]\n{setting}')
+
+    cli = MyCli(myclirc=myclirc)
+
+    assert cli.completer.rapidfuzz_length_coverage == expected
+
+
+@pytest.mark.parametrize(('value', 'expected'), [(None, 75.0), ('', 75.0), ('82.5', 82.5), ('0', 0.0), ('-1', 0.0), ('101', 100.0)])
+def test_init_configures_rapidfuzz_score_cutoff(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path, value: str | None, expected: float
+) -> None:
+    patch_constructor_side_effects(monkeypatch)
+    setting = f'rapidfuzz_score_cutoff = {value}\n' if value is not None else ''
+    myclirc = write_myclirc(tmp_path, f'[main]\n{setting}')
+
+    cli = MyCli(myclirc=myclirc)
+
+    assert cli.completer.rapidfuzz_score_cutoff == expected
+
+
+@pytest.mark.parametrize('value', ['', 'rapidfuzz'])
+def test_init_reads_empty_or_single_match_order(monkeypatch: pytest.MonkeyPatch, tmp_path: Path, value: str) -> None:
+    patch_constructor_side_effects(monkeypatch)
+    myclirc = write_myclirc(tmp_path, f'[main]\ncompletion_match_order = {value}\n')
+
+    cli = MyCli(myclirc=myclirc)
+
+    assert cli.completer.completion_match_order[0] == (value or 'perfect')
+
+
+def test_init_reports_invalid_completion_match_order(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    patch_constructor_side_effects(monkeypatch)
+    messages: list[str] = []
+    monkeypatch.setattr(MyCli, 'echo', lambda self, message, **kwargs: messages.append(message))
+    myclirc = write_myclirc(tmp_path, '[main]\ncompletion_match_order = invalid\n')
+
+    cli = MyCli(myclirc=myclirc)
+
+    assert cli.completer.completion_match_order == ('perfect', 'regex', 'under_words', 'slash_words', 'camel_case', 'rapidfuzz')
+    assert messages == ['Invalid completion_match_order; using the default order.']
+
+
 def test_init_reports_invalid_ssl_mode(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
     patch_constructor_side_effects(monkeypatch)
     echo_calls: list[tuple[str, dict[str, Any]]] = []