mycli 2.23.0__tar.gz → 2.24.1__tar.gz

{mycli-2.23.0 → mycli-2.24.1}/.github/workflows/publish.yml

@@ -305,6 +305,9 @@ jobs:
       with:
         context: .
         file: docker/Dockerfile
+        # avoids pull error: unsupported media type application/vnd.oci.empty.v1+json
+        # by publishing a v2 mediaType
+        load: true
         push: true
         tags: ${{ steps.meta.outputs.tags }}
         labels: ${{ steps.meta.outputs.labels }}

{mycli-2.23.0/mycli.egg-info → mycli-2.24.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycli
-Version: 2.23.0
+Version: 2.24.1
 Summary: Rich MySQL terminal client with autocompletion, syntax highlighting, and dataframes
 Author: Mycli Core Team
 License-Expression: BSD-3-Clause

{mycli-2.23.0 → mycli-2.24.1}/changelog.md

@@ -1,3 +1,25 @@
+2.24.1 (2026/09/12)
+==============
+
+Bug Fixes
+--------
+* Omitted completion-candidate methods are no longer applied at all.
+* Set `docker` output-type on ghcr.io images.
+
+
+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)
 ==============
 

{mycli-2.23.0 → mycli-2.24.1}/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.23.0 → mycli-2.24.1}/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.23.0 → mycli-2.24.1}/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.23.0 → mycli-2.24.1}/mycli/myclirc

@@ -9,6 +9,41 @@ show_warnings = False
 # possible completions will be listed.
 smart_completion = True
 
+# Methods to find completion candidates, in priority order.  Empty means the
+# default list.  Filename matching requires perfect and/or slash_words to be
+# listed.  Polars completions uses its own methods.
+# * 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.23.0 → mycli-2.24.1}/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.23.0 → mycli-2.24.1}/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 or default_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())
@@ -1309,20 +1337,21 @@ class SQLCompleter(Completer):
     def find_fuzzy_match(
         self,
         item: str,
-        pattern: re.Pattern[str],
+        pattern: re.Pattern[str] | None,
         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 is not None 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,17 +1362,22 @@ class SQLCompleter(Completer):
         collection: Collection[Any],
     ) -> list[tuple[str, int]]:
         completions: list[tuple[str, int]] = []
-        regex = '.{0,3}?'.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)
+        pattern = None
+        if 'regex' in self.completion_match_order:
+            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] if 'under_words' in self.completion_match_order else []
+        case_words_text = re.split(_CASE_CHANGE_PAT, last) if 'camel_case' in self.completion_match_order else []
 
         for item in collection:
             fuzziness = self.find_fuzzy_match(item, pattern, under_words_text, case_words_text)
+            if 'perfect' in self.completion_match_order and self._matches_prefix(item, text):
+                if fuzziness is None or self._match_priorities[Fuzziness.PERFECT] < self._match_priorities[fuzziness]:
+                    fuzziness = Fuzziness.PERFECT
             if fuzziness is not None:
                 completions.append((item, fuzziness))
 
-        if len(text) >= 4:
+        if 'rapidfuzz' in self.completion_match_order and len(text) >= self.rapidfuzz_min_length:
             rapidfuzz_matches = rapidfuzz.process.extract(
                 text,
                 collection,
@@ -1352,27 +1386,38 @@ 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
 
+    def _matches_prefix(self, candidate: str, text: str) -> bool:
+        if not text.startswith('`'):
+            candidate = self._strip_backticks(candidate)
+        return candidate.lower().startswith(text)
+
     def find_perfect_matches(
         self,
         text: str,
         collection: Collection[Any],
         start_only: bool,
     ) -> list[tuple[str, int]]:
+        if 'perfect' not in self.completion_match_order:
+            return []
         completions: list[tuple[str, int]] = []
-        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:
+            if self._matches_prefix(item, text) if start_only else text in item.lower():
                 completions.append((item, Fuzziness.PERFECT))
         return completions
 
@@ -1457,7 +1502,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 +1524,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 +1887,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)
-            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)
+                return (0, rank, tiebreaker, 0)
+            elif self._matches_prefix(candidate, text_for_len):
+                # 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)
@@ -1889,10 +1939,13 @@ class SQLCompleter(Completer):
 
         """
         if '/' in word:
-            for path in suggest_path_by_prefix(word, sql_only=sql_only):
-                yield (path, Fuzziness.SLASH_WORDS)
+            if 'slash_words' in self.completion_match_order:
+                for path in suggest_path_by_prefix(word, sql_only=sql_only):
+                    yield (path, Fuzziness.SLASH_WORDS)
             return
 
+        if 'perfect' not in self.completion_match_order:
+            return
         # todo position is ignored, but may need to be used
         base_path, last_path, position = parse_path(word)
         paths = suggest_path(word, sql_only=sql_only)

{mycli-2.23.0 → mycli-2.24.1/mycli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycli
-Version: 2.23.0
+Version: 2.24.1
 Summary: Rich MySQL terminal client with autocompletion, syntax highlighting, and dataframes
 Author: Mycli Core Team
 License-Expression: BSD-3-Clause

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

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

{mycli-2.23.0 → mycli-2.24.1}/test/myclirc

@@ -9,6 +9,41 @@ show_warnings = False
 # possible completions will be listed.
 smart_completion = True
 
+# Methods to find completion candidates, in priority order.  Empty means the
+# default list.  Filename matching requires perfect and/or slash_words to be
+# listed.  Polars completions uses its own methods.
+# * 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.23.0 → mycli-2.24.1}/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')
+
+
+@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]]] = []

{mycli-2.23.0 → mycli-2.24.1}/test/pytests/test_client_query.py

@@ -28,6 +28,12 @@ def make_refresh_cli() -> tuple[Any, dict[str, Any]]:
     cli.completer = SimpleNamespace(
         config_property_names=('main.show_warnings',),
         frecency_provider=lambda: {'select': 1.0},
+        completion_match_order=('under_words', 'regex'),
+        completion_tiebreaker='length',
+        rapidfuzz_min_length=2,
+        rapidfuzz_length_coverage=0.5,
+        rapidfuzz_score_cutoff=82.5,
+        regex_match_distance=5,
         keyword_casing='upper',
         indexed_column_suffix=' [indexed]',
         set_dbname=lambda dbname: state['set_dbname_calls'].append(dbname),
@@ -74,6 +80,12 @@ def test_refresh_completions_passes_options_to_refresher() -> None:
                 'indexed_column_suffix': ' [indexed]',
                 'config_property_names': ('main.show_warnings',),
                 'frecency_provider': cli.completer.frecency_provider,
+                'completion_match_order': ('under_words', 'regex'),
+                'completion_tiebreaker': 'length',
+                'rapidfuzz_min_length': 2,
+                'rapidfuzz_length_coverage': 0.5,
+                'rapidfuzz_score_cutoff': 82.5,
+                'regex_match_distance': 5,
             },
         )
     ]
@@ -104,6 +116,12 @@ def test_refresh_completions_updates_dbname_when_reset() -> None:
     cli.completer = SimpleNamespace(
         config_property_names=(),
         frecency_provider=None,
+        completion_match_order=(),
+        completion_tiebreaker='frecency',
+        rapidfuzz_min_length=4,
+        rapidfuzz_length_coverage=0.67,
+        rapidfuzz_score_cutoff=75.0,
+        regex_match_distance=3,
         keyword_casing='lower',
         indexed_column_suffix='*',
         set_dbname=lambda dbname: set_dbname_calls.append(dbname),
@@ -125,6 +143,12 @@ def test_refresh_completions_uses_lock_when_reset() -> None:
     cli.completer = SimpleNamespace(
         config_property_names=(),
         frecency_provider=None,
+        completion_match_order=(),
+        completion_tiebreaker='frecency',
+        rapidfuzz_min_length=4,
+        rapidfuzz_length_coverage=0.67,
+        rapidfuzz_score_cutoff=75.0,
+        regex_match_distance=3,
         keyword_casing='lower',
         indexed_column_suffix='*',
         set_dbname=lambda dbname: None,