mycli 2.16.0__tar.gz → 2.17.0__tar.gz

{mycli-2.16.0/mycli.egg-info → mycli-2.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycli
-Version: 2.16.0
+Version: 2.17.0
 Summary: Rich MySQL terminal client with autocompletion, syntax highlighting, and dataframes
 Author: Mycli Core Team
 License-Expression: BSD-3-Clause
@@ -31,7 +31,7 @@ License-File: AUTHORS.rst
 Requires-Dist: click~=8.3.3
 Requires-Dist: clickdc~=0.1.1
 Requires-Dist: cryptography~=50.0.0
-Requires-Dist: Pygments~=2.20.0
+Requires-Dist: Pygments~=2.21.0
 Requires-Dist: prompt_toolkit<4.0.0,>=3.0.41
 Requires-Dist: PyMySQL~=1.1.2
 Requires-Dist: sqlparse<0.6.0,>=0.3.0
@@ -48,10 +48,9 @@ Requires-Dist: keyring~=25.7.0
 Requires-Dist: jinja2~=3.1.6
 Requires-Dist: yaspin~=3.4.0
 Provides-Extra: llm
-Requires-Dist: llm~=0.31.1; extra == "llm"
+Requires-Dist: llm~=0.33; extra == "llm"
 Requires-Dist: setuptools==83.*; extra == "llm"
 Requires-Dist: pip~=26.1.2; extra == "llm"
-Requires-Dist: openai~=2.48.0; extra == "llm"
 Provides-Extra: dataframe
 Requires-Dist: polars~=1.42.1; extra == "dataframe"
 Requires-Dist: altair~=6.2.2; extra == "dataframe"
@@ -61,14 +60,14 @@ Requires-Dist: mycli[dataframe,llm]; extra == "all"
 Provides-Extra: dev
 Requires-Dist: behave~=1.3.3; extra == "dev"
 Requires-Dist: coverage~=7.13.4; extra == "dev"
-Requires-Dist: mypy~=2.3.0; extra == "dev"
+Requires-Dist: mypy~=2.3.1; extra == "dev"
 Requires-Dist: pexpect~=4.9.0; extra == "dev"
 Requires-Dist: pytest~=9.1.1; extra == "dev"
 Requires-Dist: pytest-cov~=7.0.0; extra == "dev"
 Requires-Dist: pytest-random-order~=1.2.0; extra == "dev"
 Requires-Dist: tox~=4.35.0; extra == "dev"
 Requires-Dist: pdbpp~=0.11.7; extra == "dev"
-Requires-Dist: ruff~=0.15.0; extra == "dev"
+Requires-Dist: ruff~=0.16.3; extra == "dev"
 Dynamic: license-file
 
 # mycli

{mycli-2.16.0 → mycli-2.17.0}/changelog.md

@@ -1,3 +1,22 @@
+2.17.0 (2026/08/25)
+==============
+
+Features
+--------
+* Sort completion candidates by frecency from history.
+* Add help snippets in special /command completions.
+* Add completions on Polars methods in dataframe transforms.
+
+
+Internal
+---------
+* Upgrade `pygments` to v2.21.0, removing hacks for `set*` identifiers.
+* Upgrade `llm` dependency to v3.33, removing pin for `openai`.
+* Remove `pygments` cooldown exception as no longer needed.
+* Upgrade `mypy` dev dependency to v2.3.1.
+* Upgrade `ruff` dev dependency to v0.16.3.
+
+
 2.16.0 (2026/08/22)
 ==============
 

{mycli-2.16.0 → mycli-2.17.0}/mycli/client_commands.py

@@ -17,6 +17,7 @@ from mycli.packages import special
 from mycli.packages.batch_utils import statements_from_filehandle
 from mycli.packages.filepaths import dir_path_exists
 from mycli.packages.interactive_utils import confirm_destructive_query
+from mycli.packages.ptoolkit.history import FileHistoryWithTimestamp
 from mycli.packages.special import main as special_main
 from mycli.packages.special.iocommands import expand_favorite_query
 from mycli.packages.special.main import ArgType, SpecialCommandAlias
@@ -222,6 +223,7 @@ class ClientCommandsMixin:
         destructive_keywords: Any
         config: Any
         myclirc_path: str
+        prompt_session: Any
         prompt_format: str
 
         def refresh_completions(self, reset: bool = False) -> list[SQLResult]: ...
@@ -235,6 +237,7 @@ class ClientCommandsMixin:
             "/use <database>",
             "Change to a new database.",
             aliases=[SpecialCommandAlias("\\u", case_sensitive=False)],
+            completion_snippet='change databases',
         )
         special.register_special_command(
             self.manual_reconnect,
@@ -243,14 +246,16 @@ class ClientCommandsMixin:
             "Reconnect to the server, optionally switching databases.",
             case_sensitive=True,
             aliases=[SpecialCommandAlias("\\r", case_sensitive=True)],
+            completion_snippet='reconnect to server',
         )
         special.register_special_command(
-            self.refresh_completions,
+            self.rehash,
             "rehash",
             "/rehash",
             "Refresh auto-completions.",
             arg_type=ArgType.NO_ARGUMENT,
             aliases=[SpecialCommandAlias("\\#", case_sensitive=False)],
+            completion_snippet='refresh completions',
         )
         special.register_special_command(
             self.change_table_format,
@@ -259,6 +264,7 @@ class ClientCommandsMixin:
             "Change the table format used to output interactive results.",
             case_sensitive=True,
             aliases=[SpecialCommandAlias("\\T", case_sensitive=True)],
+            completion_snippet='change interactive output format',
         )
         special.register_special_command(
             self.change_redirect_format,
@@ -267,6 +273,7 @@ class ClientCommandsMixin:
             "Change the table format used to output redirected results.",
             case_sensitive=True,
             aliases=[SpecialCommandAlias("\\Tr", case_sensitive=True)],
+            completion_snippet='change redirected output format',
         )
         special.register_special_command(
             self.execute_from_file,
@@ -274,6 +281,7 @@ class ClientCommandsMixin:
             "/source [--special|--show|--page] <file>",
             "Execute queries from a file.",
             aliases=[SpecialCommandAlias("\\.", case_sensitive=False)],
+            completion_snippet='execute queries from file',
         )
         special.register_special_command(
             self.change_prompt_format,
@@ -282,12 +290,14 @@ class ClientCommandsMixin:
             "Show or change prompt format.",
             case_sensitive=True,
             aliases=[SpecialCommandAlias("\\R", case_sensitive=True)],
+            completion_snippet='show or change prompt format',
         )
         special.register_special_command(
             self.config_command,
             r'\config',
             '/config <help|get|search|edit> [key]',
             'Inspect settings from config files.',
+            completion_snippet='inspect config file settings',
         )
 
     def manual_reconnect(self, arg: str = "", **_) -> Generator[SQLResult, None, None]:
@@ -302,6 +312,13 @@ class ClientCommandsMixin:
         else:
             yield self.change_db(arg).send(None)
 
+    def rehash(self) -> list[SQLResult]:
+        prompt_session = getattr(self, 'prompt_session', None)
+        history = getattr(prompt_session, 'history', None)
+        if isinstance(history, FileHistoryWithTimestamp):
+            history.refresh_frecency()
+        return self.refresh_completions()
+
     def change_table_format(self, arg: str, **_) -> Generator[SQLResult, None, None]:
         try:
             self.main_formatter.format_name = arg

{mycli-2.16.0 → mycli-2.17.0}/mycli/client_query.py

@@ -59,6 +59,7 @@ class ClientQueryMixin:
                 "keyword_casing": self.completer.keyword_casing,
                 "indexed_column_suffix": self.completer.indexed_column_suffix,
                 "config_property_names": self.completer.config_property_names,
+                'frecency_provider': self.completer.frecency_provider,
             },
         )
 

{mycli-2.16.0 → mycli-2.17.0}/mycli/completion_refresher.py

@@ -267,7 +267,7 @@ def refresh_collations(completer: SQLCompleter, executor: SQLExecute) -> None:
 
 @refresher("special_commands")
 def refresh_special(completer: SQLCompleter, executor: SQLExecute) -> None:
-    completer.extend_special_commands(list(COMMANDS.keys()))
+    completer.extend_special_commands({command: details.completion_snippet or details.description for command, details in COMMANDS.items()})
 
 
 @refresher("show_commands")

{mycli-2.16.0 → mycli-2.17.0}/mycli/lexer.py

@@ -1,6 +1,6 @@
 from pygments.lexer import inherit
 from pygments.lexers.sql import MySqlLexer
-from pygments.token import Keyword, Name
+from pygments.token import Keyword
 
 
 class MyCliLexer(MySqlLexer):
@@ -8,8 +8,6 @@ class MyCliLexer(MySqlLexer):
 
     tokens = {
         "root": [
-            # TODO: Remove once Pygments is upgraded above v2.20.0.
-            (r"\bset[\w$]+\b", Name),
             (r"\brepair\b", Keyword),
             (r"\boffset\b", Keyword),
             inherit,

{mycli-2.16.0 → mycli-2.17.0}/mycli/main_modes/repl.py

@@ -74,7 +74,7 @@ from mycli.packages.polars_transform import (
     prepare_polars_transform,
     run_polars_transform,
 )
-from mycli.packages.ptoolkit.history import FileHistoryWithTimestamp
+from mycli.packages.ptoolkit.history import FRECENCY_HISTORY_ENTRIES, FRECENCY_REFRESH_INTERVAL, FileHistoryWithTimestamp
 from mycli.packages.special.utils import format_uptime, get_ssl_version, get_uptime, get_warning_count
 from mycli.packages.sql_utils import (
     extract_new_password,
@@ -146,7 +146,13 @@ def complete_while_typing_filter() -> bool:
 def _create_history(mycli: 'MyCli') -> FileHistoryWithTimestamp | None:
     history_file = os.path.expanduser(os.environ.get('MYCLI_HISTFILE', mycli.config['main'].get('history_file', '~/.mycli-history')))
     if dir_path_exists(history_file):
-        return FileHistoryWithTimestamp(history_file)
+        frecency_history_entries = int(mycli.config['main'].get('frecency_history_entries', FRECENCY_HISTORY_ENTRIES) or 0)
+        frecency_refresh_interval = int(mycli.config['main'].get('frecency_refresh_interval', FRECENCY_REFRESH_INTERVAL) or 0)
+        return FileHistoryWithTimestamp(
+            history_file,
+            frecency_history_entries=frecency_history_entries,
+            frecency_refresh_interval=frecency_refresh_interval,
+        )
 
     mycli.echo(
         f'Error: Unable to open the history file "{history_file}". Your query history will not be saved.',
@@ -1113,10 +1119,12 @@ def main_repl(mycli: 'MyCli') -> None:
 
     mycli.configure_pager()
     _configure_editor(mycli)
+    history = _create_history(mycli)
+    if history is not None:
+        mycli.completer.frecency_provider = lambda: history.frecency
     if mycli.smart_completion and not mycli.sandbox_mode:
         mycli.refresh_completions()
 
-    history = _create_history(mycli)
     key_bindings = mycli_bindings(mycli)
     _show_startup_banner(mycli, sqlexecute)
     _build_prompt_session(mycli, state, history, key_bindings)

{mycli-2.16.0 → mycli-2.17.0}/mycli/myclirc

@@ -54,6 +54,14 @@ destructive_keywords = DROP SHUTDOWN DELETE TRUNCATE ALTER UPDATE
 # interactive query history location.
 history_file = ~/.mycli-history
 
+# Number of recent history entries used to calculate frecency. Set to 0 or
+# leave empty to disable frecency calculation entirely.
+frecency_history_entries = 1000
+
+# Number of REPL entries between frecency recalculation. Set to 0 to disable
+# periodic recalculation.
+frecency_refresh_interval = 50
+
 # log_file location.
 log_file = ~/.mycli.log
 

mycli-2.17.0/mycli/packages/polars_completion.py

@@ -0,0 +1,293 @@
+from __future__ import annotations
+
+import ast
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from functools import lru_cache
+import inspect
+from io import StringIO
+import re
+import sys
+import tokenize
+from types import ModuleType, UnionType
+from typing import Any, Union, cast, get_args, get_origin
+
+import sqlglot
+
+from mycli.packages.polars_transform import _pipeline_operator_indexes
+
+_ATTRIBUTE_PATTERN = re.compile(r'(?s)(.*)\.([A-Za-z_][A-Za-z0-9_]*)?\s*$')
+_ANNOTATION_NAME_PATTERN = re.compile(r'[A-Za-z_][A-Za-z0-9_]*')
+_SENTINEL = '__mycli_polars_completion__'
+_OPEN_TO_CLOSE = {'(': ')', '[': ']', '{': '}'}
+_CLOSE = frozenset(_OPEN_TO_CLOSE.values())
+
+
+@dataclass(frozen=True, slots=True)
+class PolarsCompletion:
+    text: str
+    display: str
+    display_meta: str
+    start_position: int
+
+
+def complete_polars_transform(command: str) -> list[PolarsCompletion] | None:
+    """Return safe attribute completions for a Polars transform expression."""
+    try:
+        tokens = sqlglot.tokenize(command)
+        pipe_index, output_index = _pipeline_operator_indexes(command, tokens, require_operands=False)
+    except sqlglot.errors.TokenError:
+        return None
+    if pipe_index is None:
+        return None
+    if output_index is not None:
+        return []
+
+    pipe = tokens[pipe_index + 1]
+    expression = command[pipe.end + 1 :].strip()
+    match = _ATTRIBUTE_PATTERN.fullmatch(expression)
+    if match is None:
+        return []
+    prefix = match.group(2) or ''
+    source = f'{match.group(1)}.{_SENTINEL}'
+    closed_source = _close_open_delimiters(source)
+    if closed_source is None:
+        return []
+    try:
+        parsed = ast.parse(closed_source, mode='eval')
+    except SyntaxError:
+        return []
+    target = next(
+        (node for node in ast.walk(parsed) if isinstance(node, ast.Attribute) and node.attr == _SENTINEL),
+        None,
+    )
+    if target is None:
+        return []
+
+    polars = _load_polars()
+    if polars is None:
+        return []
+    owner = _infer_type(target.value, polars)
+    if owner is None:
+        return []
+    return [
+        PolarsCompletion(
+            text=f'{name}(' if is_callable else name,
+            display=name,
+            display_meta=metadata,
+            start_position=-len(prefix),
+        )
+        for name, is_callable, metadata in _members(owner, polars)
+        if name.startswith(prefix)
+    ]
+
+
+def _close_open_delimiters(source: str) -> str | None:
+    stack: list[str] = []
+    try:
+        tokens = tokenize.generate_tokens(StringIO(source).readline)
+        for token in tokens:
+            if token.type != tokenize.OP:
+                continue
+            if token.string in _OPEN_TO_CLOSE:
+                stack.append(token.string)
+            elif token.string in _CLOSE:
+                if not stack or _OPEN_TO_CLOSE[stack.pop()] != token.string:
+                    return None
+    except (IndentationError, tokenize.TokenError):
+        pass
+    return source + ''.join(_OPEN_TO_CLOSE[value] for value in reversed(stack))
+
+
+@lru_cache(maxsize=1)
+def _load_polars() -> Any | None:
+    try:
+        import polars as pl
+    except ImportError:
+        return None
+    return pl
+
+
+def _infer_type(node: ast.AST, polars: Any) -> Any | None:
+    if isinstance(node, ast.Name):
+        if node.id == 'df':
+            return polars.DataFrame
+        if node.id == 'pl':
+            return polars
+        return None
+    if isinstance(node, ast.Subscript):
+        owner = _infer_type(node.value, polars)
+        if owner is polars.DataFrame:
+            return polars.Series
+        if owner is polars.Expr:
+            return polars.Expr
+        return None
+    if isinstance(node, ast.Attribute):
+        owner = _infer_type(node.value, polars)
+        member = _static_member(owner, node.attr)
+        if member is None:
+            return None
+        if isinstance(member, property):
+            return _return_type(member.fget, owner, polars)
+        if inspect.isclass(member) or isinstance(member, ModuleType):
+            return member
+        return None
+    if isinstance(node, ast.Call):
+        if isinstance(node.func, ast.Attribute):
+            owner = _infer_type(node.func.value, polars)
+            member = _static_member(owner, node.func.attr)
+            return _call_return_type(member, owner, polars)
+        return None
+    if isinstance(node, (ast.BinOp, ast.BoolOp, ast.Compare, ast.UnaryOp)):
+        inferred = [_infer_type(child, polars) for child in ast.iter_child_nodes(node)]
+        if polars.Expr in inferred:
+            return polars.Expr
+        if polars.Series in inferred:
+            return polars.Series
+    return None
+
+
+def _static_member(owner: Any | None, name: str) -> Any | None:
+    if owner is None:
+        return None
+    try:
+        member = inspect.getattr_static(owner, name)
+    except AttributeError:
+        return None
+    if isinstance(member, (classmethod, staticmethod)):
+        return member.__func__
+    return member
+
+
+def _call_return_type(member: Any | None, owner: Any, polars: Any) -> Any | None:
+    if member is None:
+        return None
+    if inspect.isclass(member):
+        return member
+    result = _return_type(member, owner, polars)
+    if result is not None:
+        return result
+    call = _static_member(type(member), '__call__')
+    return _return_type(call, owner, polars)
+
+
+def _return_type(callable_object: Any | None, owner: Any, polars: Any) -> Any | None:
+    if callable_object is None:
+        return None
+    if inspect.isroutine(callable_object):
+        annotations = getattr(callable_object, '__annotations__', {})
+    else:
+        try:
+            annotations = inspect.getattr_static(callable_object, '__annotations__')
+        except AttributeError:
+            annotations = {}
+    if not isinstance(annotations, Mapping):
+        return None
+    annotation = annotations.get('return')
+    if annotation is None or annotation is inspect.Signature.empty:
+        return None
+    if annotation is Any:
+        return None
+    if inspect.isclass(annotation):
+        return annotation if _is_polars_type(annotation) else None
+    arguments = get_args(annotation)
+    if arguments:
+        origin = cast(Any, get_origin(annotation))
+        if origin not in (Union, UnionType):
+            return None
+        for argument in arguments:
+            resolved = _resolve_annotation(argument, callable_object, owner, polars)
+            if resolved is not None:
+                return resolved
+    return _resolve_annotation(annotation, callable_object, owner, polars)
+
+
+def _resolve_annotation(annotation: Any, callable_object: Any, owner: Any, polars: Any) -> Any | None:
+    if inspect.isclass(annotation):
+        return annotation if _is_polars_type(annotation) else None
+    if not isinstance(annotation, str):
+        return None
+    if annotation in ('Self', 'typing.Self'):
+        return owner
+    if '[' in annotation:
+        return None
+    namespace = getattr(callable_object, '__globals__', {}) if inspect.isroutine(callable_object) else {}
+    for name in _ANNOTATION_NAME_PATTERN.findall(annotation):
+        candidate = namespace.get(name)
+        if not inspect.isclass(candidate):
+            candidate = _static_member(polars, name)
+        if not inspect.isclass(candidate):
+            candidate = _polars_types_by_name(polars).get(name)
+        if inspect.isclass(candidate) and _is_polars_type(candidate):
+            return candidate
+    return None
+
+
+def _is_polars_type(value: type[Any]) -> bool:
+    return value.__module__ == 'polars' or value.__module__.startswith('polars.')
+
+
+@lru_cache(maxsize=1)
+def _polars_types_by_name(polars: Any) -> Mapping[str, type[Any]]:
+    """Index classes in loaded Polars modules without importing annotation paths."""
+    candidates: dict[str, type[Any] | None] = {}
+    modules = [
+        module
+        for module_name, module in tuple(sys.modules.items())
+        if module is not None and (module is polars or module_name.startswith('polars.'))
+    ]
+    for module in modules:
+        for value in vars(module).values():
+            if not inspect.isclass(value) or not _is_polars_type(value):
+                continue
+            name = value.__name__
+            existing = candidates.get(name, value)
+            candidates[name] = value if existing is value else None
+    return {name: value for name, value in candidates.items() if value is not None}
+
+
+@lru_cache(maxsize=None)
+def _members(owner: Any, polars: Any) -> tuple[tuple[str, bool, str], ...]:
+    members: list[tuple[str, bool, str]] = []
+    for name in dir(owner):
+        if name.startswith('_'):
+            continue
+        member = _static_member(owner, name)
+        if member is None:
+            continue
+        if isinstance(member, property):
+            members.append((name, False, _property_metadata(member, owner, polars)))
+        elif callable(member):
+            members.append((name, True, _signature_metadata(member)))
+    return tuple(members)
+
+
+def _property_metadata(member: property, owner: Any, polars: Any) -> str:
+    result = _return_type(member.fget, owner, polars)
+    return result.__name__ if inspect.isclass(result) else 'property'
+
+
+def _signature_metadata(member: Callable[..., Any]) -> str:
+    callable_object: Any = member
+    try:
+        signature = inspect.signature(callable_object)
+    except (TypeError, ValueError):
+        callable_object = _static_member(type(member), '__call__')
+        try:
+            signature = inspect.signature(callable_object)
+        except (TypeError, ValueError):
+            return '()'
+    parameters = [parameter for parameter in signature.parameters.values() if parameter.name not in ('self', 'cls')]
+    rendered: list[str] = []
+    for parameter in parameters[:4]:
+        text = parameter.name
+        if parameter.kind == inspect.Parameter.VAR_POSITIONAL:
+            text = f'*{text}'
+        elif parameter.kind == inspect.Parameter.VAR_KEYWORD:
+            text = f'**{text}'
+        elif parameter.default is not inspect.Parameter.empty:
+            text = f'{text}=...'
+        rendered.append(text)
+    if len(parameters) > 4:
+        rendered.append('...')
+    return f"({', '.join(rendered)})"

{mycli-2.16.0 → mycli-2.17.0}/mycli/packages/polars_transform.py

@@ -66,30 +66,7 @@ def parse_polars_transform(command: str) -> PolarsPipeline | None:
     except sqlglot.errors.TokenError as exc:
         raise PolarsTransformError(f'Unable to parse Polars transform: {exc}') from exc
 
-    pipe_index: int | None = None
-    parquet_index: int | None = None
-    for index, token in enumerate(tokens[:-1]):
-        following = tokens[index + 1]
-        if token.token_type != sqlglot.TokenType.DOT:
-            continue
-        if token.start == 0 or not command[token.start - 1].isspace():
-            continue
-        if following.token_type not in (sqlglot.TokenType.PIPE, sqlglot.TokenType.GT):
-            continue
-        if following.end + 1 >= len(command):
-            if following.token_type == sqlglot.TokenType.PIPE:
-                raise PolarsTransformError('Polars transforms require a Python expression.')
-            raise PolarsTransformError('File saves require a destination path.')
-        if not command[following.end + 1].isspace():
-            continue
-        if following.token_type == sqlglot.TokenType.PIPE:
-            if pipe_index is not None:
-                raise PolarsTransformError('Polars transforms support only one ".|" operator.')
-            pipe_index = index
-        else:
-            if parquet_index is not None:
-                raise PolarsTransformError('File saves support only one ".>" operator.')
-            parquet_index = index
+    pipe_index, parquet_index = _pipeline_operator_indexes(command, tokens)
 
     if pipe_index is None and parquet_index is None:
         return None
@@ -138,6 +115,41 @@ def parse_polars_transform(command: str) -> PolarsPipeline | None:
     return PolarsPipeline(sql=sql, expression=expression, output_path=output_path, output_mode=output_mode)
 
 
+def _pipeline_operator_indexes(
+    command: str,
+    tokens: list[sqlglot.Token],
+    *,
+    require_operands: bool = True,
+) -> tuple[int | None, int | None]:
+    """Locate transform and redirect operators in tokenized command text."""
+
+    pipe_index: int | None = None
+    parquet_index: int | None = None
+    for index, token in enumerate(tokens[:-1]):
+        following = tokens[index + 1]
+        if token.token_type != sqlglot.TokenType.DOT:
+            continue
+        if token.start == 0 or not command[token.start - 1].isspace():
+            continue
+        if following.token_type not in (sqlglot.TokenType.PIPE, sqlglot.TokenType.GT):
+            continue
+        if following.end + 1 >= len(command) and require_operands:
+            if following.token_type == sqlglot.TokenType.PIPE:
+                raise PolarsTransformError('Polars transforms require a Python expression.')
+            raise PolarsTransformError('File saves require a destination path.')
+        if following.end + 1 < len(command) and not command[following.end + 1].isspace():
+            continue
+        if following.token_type == sqlglot.TokenType.PIPE:
+            if pipe_index is not None:
+                raise PolarsTransformError('Polars transforms support only one ".|" operator.')
+            pipe_index = index
+        else:
+            if parquet_index is not None:
+                raise PolarsTransformError('File saves support only one ".>" operator.')
+            parquet_index = index
+    return pipe_index, parquet_index
+
+
 def _parse_output_path(path: str) -> str:
     if path[0] in ('\'', '"'):
         if len(path) < 2 or path[-1] != path[0]: