kaqing 2.0.184__py3-none-any.whl → 2.0.227__py3-none-any.whl

adam/repl_commands.py

@@ -1,13 +1,33 @@
-from adam.commands.alter_tables import AlterTables
 from adam.commands.app.app import App
 from adam.commands.app.app_ping import AppPing
 from adam.commands.app.show_app_actions import ShowAppActions
 from adam.commands.app.show_app_id import ShowAppId
 from adam.commands.app.show_app_queues import ShowAppQueues
 from adam.commands.audit.audit import Audit
-from adam.commands.cat import Cat
+from adam.commands.cassandra.restart_cluster import RestartCluster
+from adam.commands.cassandra.restart_node import RestartNode
+from adam.commands.cassandra.restart_nodes import RestartNodes
+from adam.commands.cassandra.rollout import RollOut
+from adam.commands.cassandra.show_cassandra_repairs import ShowCassandraRepairs
+from adam.commands.cassandra.show_cassandra_status import ShowCassandraStatus
+from adam.commands.cassandra.show_cassandra_version import ShowCassandraVersion
+from adam.commands.cassandra.show_processes import ShowProcesses
+from adam.commands.cassandra.show_storage import ShowStorage
+from adam.commands.cassandra.watch import Watch
+from adam.commands.cli.clipboard_copy import ClipboardCopy
+from adam.commands.config.param_get import GetParam
+from adam.commands.config.param_set import SetParam
+from adam.commands.debug.show_offloaded_completes import ShowOffloadedCompletes
+from adam.commands.diag.check import Check
+from adam.commands.diag.generate_report import GenerateReport
+from adam.commands.diag.issues import Issues
+from adam.commands.fs.cat import Cat
 from adam.commands.code import Code
-from adam.commands.download_file import DownloadFile
+from adam.commands.cql.alter_tables import AlterTables
+from adam.commands.debug.debug import Debug
+from adam.commands.cassandra.download_cassandra_log import DownloadCassandraLog
+from adam.commands.fs.cat_local import CatLocal
+from adam.commands.fs.download_file import DownloadFile
 from adam.commands.deploy.code_start import CodeStart
 from adam.commands.deploy.code_stop import CodeStop
 from adam.commands.deploy.deploy import Deploy
@@ -31,58 +51,51 @@ from adam.commands.export.import_session import ImportSession
 from adam.commands.export.clean_up_export_sessions import CleanUpExportSessions
 from adam.commands.export.clean_up_all_export_sessions import CleanUpAllExportSessions
 from adam.commands.export.drop_export_databases import DropExportDatabases
-from adam.commands.export.export_select import ExportSelect
+from adam.commands.export.export_x_select import ExportXSelect
 from adam.commands.export.export_use import ExportUse
-from adam.commands.export.export_select_x import ExportSelectX
+from adam.commands.export.export_select import ExportSelect
 from adam.commands.export.show_column_counts import ShowColumnCounts
 from adam.commands.export.show_export_databases import ShowExportDatabases
 from adam.commands.export.show_export_session import ShowExportSession
 from adam.commands.export.show_export_sessions import ShowExportSessions
-from adam.commands.find_files import FindLocalFiles
-from adam.commands.find_processes import FindProcesses
-from adam.commands.head import Head
+from adam.commands.fs.find_files import FindLocalFiles
+from adam.commands.fs.find_processes import FindProcesses
+from adam.commands.fs.head import Head
+from adam.commands.fs.head_local import HeadLocal
+from adam.commands.fs.ls_local import LsLocal
+from adam.commands.fs.rm import RmLocal
+from adam.commands.fs.rm_logs import RmLogs
+from adam.commands.fs.show_last_results import ShowLastResults
+from adam.commands.fs.tail import Tail
+from adam.commands.fs.tail_local import TailLocal
 from adam.commands.kubectl import Kubectl
-from adam.commands.shell import Shell
-from adam.commands.clipboard_copy import ClipboardCopy
+from adam.commands.fs.shell import Shell
 from adam.commands.bash.bash import Bash
-from adam.commands.cd import Cd
-from adam.commands.check import Check
+from adam.commands.fs.cd import Cd
 from adam.commands.command import Command
 from adam.commands.cql.cqlsh import Cqlsh
 from adam.commands.exit import Exit
 from adam.commands.medusa.medusa import Medusa
-from adam.commands.param_get import GetParam
-from adam.commands.issues import Issues
-from adam.commands.ls import Ls
-from adam.commands.nodetool import NodeTool
+from adam.commands.fs.ls import Ls
+from adam.commands.nodetool.nodetool import NodeTool
 from adam.commands.postgres.postgres import Postgres, PostgresPg
 from adam.commands.preview_table import PreviewTable
-from adam.commands.pwd import Pwd
+from adam.commands.fs.pwd import Pwd
 from adam.commands.reaper.reaper import Reaper
 from adam.commands.repair.repair import Repair
-from adam.commands.report import Report
-from adam.commands.restart import Restart
-from adam.commands.rollout import RollOut
-from adam.commands.param_set import SetParam
-from adam.commands.show.show import Show
-from adam.commands.show.show_cassandra_status import ShowCassandraStatus
-from adam.commands.show.show_cassandra_version import ShowCassandraVersion
-from adam.commands.show.show_commands import ShowKubectlCommands
-from adam.commands.show.show_host import ShowHost
-from adam.commands.show.show_login import ShowLogin
-from adam.commands.show.show_params import ShowParams
-from adam.commands.show.show_processes import ShowProcesses
-from adam.commands.show.show_cassandra_repairs import ShowCassandraRepairs
-from adam.commands.show.show_storage import ShowStorage
-from adam.commands.show.show_adam import ShowAdam
-from adam.commands.watch import Watch
+from adam.commands.cli.show_cli_commands import ShowKubectlCommands
+from adam.commands.fs.show_host import ShowHost
+from adam.commands.app.show_login import ShowLogin
+from adam.commands.config.show_params import ShowParams
+from adam.commands.fs.show_adam import ShowAdam
+from adam.commands.show import Show
 
 class ReplCommands:
     def repl_cmd_list() -> list[Command]:
         cmds: list[Command] = ReplCommands.navigation() + ReplCommands.cassandra_ops() + ReplCommands.postgres_ops() + \
             ReplCommands.app_ops() + ReplCommands.audit_ops() + ReplCommands.export_ops() + ReplCommands.tools() + ReplCommands.exit()
 
-        intermediate_cmds: list[Command] = [App(), Audit(), Reaper(), Repair(), Deploy(), Show(), Undeploy()]
+        intermediate_cmds: list[Command] = [App(), Audit(), Reaper(), Repair(), Debug(), Deploy(), Show(), Undeploy()]
         ic = [c.command() for c in intermediate_cmds]
         # 1. dedup commands
         deduped = []
@@ -99,18 +112,28 @@ class ReplCommands:
         return deduped
 
     def navigation() -> list[Command]:
-        return [Ls(), PreviewTable(), DeviceApp(), DevicePostgres(), DeviceCass(), DeviceAuditLog(), DeviceExport(),
-                Cd(), Cat(), Head(), DownloadFile(), FindLocalFiles(), FindProcesses(), Pwd(), ClipboardCopy(),
-                GetParam(), SetParam(), ShowParams(), ShowKubectlCommands(), ShowLogin(), ShowAdam(), ShowHost()]
+        return [Cd(), Cat(), CatLocal(), ClipboardCopy(),
+                DeviceApp(), DevicePostgres(), DeviceCass(), DeviceAuditLog(), DeviceExport(),
+                DownloadFile(), FindLocalFiles(), FindProcesses(), GetParam(),
+                Head(), HeadLocal(), Ls(), LsLocal(), PreviewTable(), Pwd(), RmLogs(),
+                SetParam(), ShowAdam(), ShowHost(), ShowKubectlCommands(), ShowLastResults(),
+                ShowLogin(), ShowOffloadedCompletes(), ShowParams(),
+                Tail(), TailLocal()] + \
+                RmLocal().cmd_list()
 
     def cassandra_ops() -> list[Command]:
-        return [Cqlsh(), ShowCassandraStatus(), ShowCassandraVersion(), ShowCassandraRepairs(), ShowStorage(), ShowProcesses(),
-                Check(), Issues(), NodeTool(), Report(), AlterTables(), Bash(),
-                ExportTables(), ExportSelect(), ExportUse(),  ShowExportDatabases(), ShowColumnCounts(),
-                DropExportDatabase(), DropExportDatabases(),
-                ShowExportSessions(), ShowExportSession(), DownloadExportSession(),
-                CleanUpExportSessions(), CleanUpAllExportSessions(), ImportSession(), ImportCSVFiles()] + \
-                Medusa().cmd_list() + [Restart(), RollOut(), Watch()] + Reaper().cmd_list() + Repair().cmd_list()
+        return [AlterTables(), Bash(), Check(), CleanUpExportSessions(), CleanUpAllExportSessions(), Cqlsh(),
+                DownloadCassandraLog(), DropExportDatabase(), DropExportDatabases(), DownloadExportSession(),
+                ExportTables(), ExportXSelect(), ExportUse(),
+                GenerateReport(), ImportSession(), ImportCSVFiles(), Issues(), NodeTool(),
+                RestartNodes(), RestartNode(), RestartCluster(), RollOut(),
+                ShowCassandraStatus(), ShowCassandraVersion(), ShowCassandraRepairs(), ShowColumnCounts(),
+                ShowStorage(), ShowExportDatabases(), ShowExportSessions(), ShowExportSession(), ShowProcesses(),
+                Watch()] + \
+                Debug().cmd_list() + \
+                Medusa().cmd_list() + \
+                Reaper().cmd_list() + \
+                Repair().cmd_list()
 
     def postgres_ops() -> list[Command]:
         return [Postgres(), DeployPgAgent(), UndeployPgAgent(), PostgresPg()]
@@ -122,7 +145,7 @@ class ReplCommands:
         return [Audit()] + Audit().cmd_list()
 
     def export_ops() -> list[Command]:
-        return [ExportSelectX(), DropExportDatabase(), DropExportDatabases(), ShowColumnCounts()]
+        return [ExportSelect(), DropExportDatabase(), DropExportDatabases(), ShowColumnCounts()]
 
     def tools() -> list[Command]:
         return [Shell(), CodeStart(), CodeStop(), DeployFrontend(), UndeployFrontend(), DeployPod(), UndeployPod(), Kubectl(), Code()]

adam/repl_session.py

@@ -1,6 +1,10 @@
+from typing import Union
 from prompt_toolkit import PromptSession
 from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
 
+from adam.config import Config
+from adam.utils import ConfigHolder, LogFile
+
 class ReplSession:
     # the singleton pattern
     def __new__(cls, *args, **kwargs):
@@ -10,4 +14,15 @@ class ReplSession:
 
     def __init__(self):
         if not hasattr(self, 'prompt_session'):
-            self.prompt_session = PromptSession(auto_suggest=AutoSuggestFromHistory())
+            self.prompt_session = PromptSession(auto_suggest=AutoSuggestFromHistory())
+            ConfigHolder().append_command_history = self.append_history
+
+    def append_history(self, entry: Union[str, LogFile]):
+        if not entry:
+            return
+
+        if self.prompt_session and Config().get('repl.history.push-cat-remote-log-file', True):
+            if isinstance(entry, LogFile):
+                entry = entry.to_command()
+
+            self.prompt_session.history.append_string(entry)

adam/repl_state.py

@@ -61,6 +61,7 @@ class ReplState:
         self.bash_session = bash_session
         self.remote_dir = remote_dir
         self.original_state: ReplState = None
+        self.pod_targetted = False
 
         self.export_session: str = None
 
@@ -392,9 +393,10 @@ class ReplState:
         self.pop()
         self.bash_session = None
 
-    def push(self):
+    def push(self, pod_targetted=False):
         if not self.original_state:
             self.original_state = copy(self)
+            self.pod_targetted = pod_targetted
 
     def pop(self):
         if o := self.original_state:
@@ -409,6 +411,7 @@ class ReplState:
             self.namespace = o.namespace
 
             self.original_state = None
+            self.pod_targetted = False
 
     def pg_host_n_database(self):
         host = None
@@ -422,6 +425,18 @@ class ReplState:
 
         return host, database
 
+    def with_no_pod(self):
+        state1 = copy(self)
+        state1.pod = None
+
+        return state1
+
+    def with_pod(self, pod: str):
+        state1 = copy(self)
+        state1.pod = pod
+
+        return state1
+
 class DevicePodService:
     def __init__(self, handler: 'DeviceExecHandler'):
         self.handler = handler

adam/sql/async_executor.py

@@ -0,0 +1,62 @@
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from copy import copy
+import inspect
+import threading
+import time
+import traceback
+
+from adam.utils import log2, log_timing
+
+class AsyncExecutor:
+    # some lib does not handle asyncio loop properly, as sync exec submit does not work, use another async loop
+
+    lock = threading.Lock()
+    in_queue = set()
+    processed: dict[str, float] = {}
+    first_processed_at: float = None
+    last_processed_at: float = None
+
+    loop: asyncio.AbstractEventLoop = None
+    async_exec: ThreadPoolExecutor = None
+
+    def preload(action: callable, log_key: str = None):
+        with AsyncExecutor.lock:
+            if not AsyncExecutor.loop:
+                AsyncExecutor.loop = asyncio.new_event_loop()
+                AsyncExecutor.async_exec = ThreadPoolExecutor(max_workers=6, thread_name_prefix='async')
+                AsyncExecutor.loop.set_default_executor(AsyncExecutor.async_exec)
+
+            async def a():
+                try:
+                    t0 = time.time()
+
+                    arg_needed = len(action.__code__.co_varnames)
+
+                    if log_key:
+                        with log_timing(log_key):
+                            r = action(None) if arg_needed else action()
+                    else:
+                        r = action(None) if arg_needed else action()
+                    if inspect.isawaitable(r):
+                        await r
+
+                    AsyncExecutor.in_queue.remove(log_key)
+                    if log_key not in AsyncExecutor.processed:
+                        AsyncExecutor.processed[log_key] = time.time() - t0
+                    AsyncExecutor.last_processed_at = time.time()
+                except Exception as e:
+                    log2('preloading error', e, inspect.getsourcelines(action)[0][0])
+                    traceback.print_exc()
+
+            if log_key not in AsyncExecutor.in_queue:
+                AsyncExecutor.in_queue.add(log_key)
+                AsyncExecutor.async_exec.submit(lambda: AsyncExecutor.loop.run_until_complete(a()))
+
+    def entries_in_queue():
+        # no locking
+        return copy(AsyncExecutor.in_queue), copy(AsyncExecutor.processed), AsyncExecutor.first_processed_at, AsyncExecutor.last_processed_at
+
+    def reset():
+        AsyncExecutor.first_processed_at = time.time()
+        AsyncExecutor.processed.clear()

adam/sql/lark_completer.py

@@ -0,0 +1,286 @@
+import functools
+import os
+from typing import Iterable
+from prompt_toolkit.completion import CompleteEvent, Completer, Completion, NestedCompleter, WordCompleter
+from prompt_toolkit.document import Document
+
+from adam.config import Config
+from adam.sql.async_executor import AsyncExecutor
+from adam.sql.lark_parser import LarkParser
+from adam.utils import debug, log_timing, offload
+from adam.utils_repl.appendable_completer import AppendableCompleter
+from adam.utils_repl.repl_completer import merge_completions
+
+__all__ = [
+    "LarkCompleter",
+]
+
+def default_columns(x: list[str]):
+    return 'id,x.,y.,z.'.split(',')
+
+class LarkCompleter(Completer, AppendableCompleter):
+    SYSTEM = 'system'
+
+    def __init__(self,
+                 dml: str = None,
+                 expandables: dict = {},
+                 variant: str = 'c',
+
+                 name: str = None,
+                 options_lambda: callable = None,
+                 auto: str = 'lazy',
+                 debug = False
+    ) -> None:
+        self.nested: NestedCompleter = None
+        self.options_lambda = options_lambda
+        if options_lambda and auto == 'lazy':
+            AsyncExecutor.preload(options_lambda, log_key=name)
+
+        self.variant = variant
+        self.parser = None
+        self.dml = dml
+        self.expandables = expandables
+
+        self.display_dict = {}
+        self.meta_dict = {}
+        self.WORD = None
+        self.sentence = False
+        self.match_middle = False
+        self.pattern = None
+
+        self.debug = debug
+
+        if variant:
+            self.parser = LarkCompleter.lark_parser(variant)
+            self.preload_lazy_auto_completes()
+
+    def __repr__(self):
+        return f"LarkCompleter.{self.variant}"
+
+    def preload_lazy_auto_completes(self):
+        for key, value in self.expandables.items():
+            if callable(value):
+                if self.auto_complete(key) == 'lazy':
+                    AsyncExecutor.preload(value, log_key=key)
+
+    def from_lambda(name: str, options_lambda: callable, auto: str = 'lazy'):
+        return LarkCompleter(name=name, options_lambda=options_lambda, auto=auto, variant=None)
+
+    @functools.lru_cache()
+    def lark_parser(variant: str):
+        dir_path = os.path.dirname(os.path.realpath(__file__))
+        with open(dir_path + f"/qingl.lark") as f:
+            grammar: str = None
+            with log_timing(f'lark.{variant}.file-read'):
+                grammar = f.read()
+
+            common_contexts = {
+                'cd_command.file_name': 'direct-dirs',
+            }
+
+            if variant in ['a', 'c0', 'p0', 'x0']:
+                grammar = grammar.replace('start: statement_sequence', f'start: qing_{variant}_statement')
+                contexts_by_path = {
+                } | common_contexts
+
+                debug(f'* GRAMMAR replaced to start: qing_{variant}_statement')
+
+                return LarkParser(grammar, contexts_by_path)
+            elif variant == 'system':
+                grammar = grammar.replace('start: statement_sequence', f'start: qing_{variant}_statement')
+                contexts_by_path = {
+                } | common_contexts
+
+                return LarkParser(grammar, contexts_by_path)
+
+            grammar = grammar.replace('qing_statement: qing_p_statement', f'qing_statement: qing_{variant}_statement')
+            debug(f'* GRAMMAR replaced to qing_statement: qing_{variant}_statement')
+
+            bash_contexts = {
+                'bash_statement.host_name': 'hosts',
+                'bash_statement.bash_command': 'bash-commands',
+            }
+
+            contexts_by_path = {
+                'describe_keyspace.keyspace_name': 'keyspaces',
+                'keyspace_ref.keyspace_path.namespace_ref.identifier_ref': 'tables',
+                'preview_table_statement.path.identifier_ref': 'tables',
+
+                'insert_statement.insert_select': 'column-names',
+                'update_statement.set_clause.path.identifier_ref': 'column-names',
+                'update_statement.where_clause.cond.expr.path.identifier_ref': 'column-names',
+                'delete_statement.where_clause.cond.expr.path.identifier_ref': 'column-names',
+
+                'select_clause.projection.result_expr.expr.path.identifier_ref': 'columns',
+                'select_from.where_clause.cond.expr.path.identifier_ref': 'columns',
+                'select_from.where_clause.cond.expr.logical_term.and_expr.cond.expr.path.identifier_ref': 'columns',
+                'select_from.group_by_clause.group_term.expr.path.identifier_ref': 'columns',
+                'select_statement.order_by_clause.ordering_term.expr.path.identifier_ref': 'columns',
+                'select_from.from_clause.from_terms.join_clause.ansi_join_clause.ansi_join_predicate.expr.path.identifier_ref': 'columns',
+                'select_from.from_clause.from_terms.join_clause.ansi_join_clause.ansi_join_predicate.expr.comparison_term.relational_expr.expr.path.identifier_ref': 'columns',
+
+                'select_from.from_clause.from_terms.from_generic.alias.identifier_ref': 'column-aliases',
+
+                'select_statement.limit_clause.expr.literal.nbr.digit': 'limits',
+            } | common_contexts
+
+            if variant == 'p':
+                contexts_by_path = bash_contexts | contexts_by_path
+            elif variant == 'c':
+                contexts_by_path = {
+                    'export_table.path.identifier_ref': 'tables',
+                    'show_column_counts_command.path.identifier_ref': 'tables',
+                    'export_statement.export_tables.keyspace_name': 'keyspaces',
+
+                    'alter_tables_statement.properties.property.property_name': 'table-props',
+                    'alter_cql_table_statement.properties.property.property_name': 'table-props',
+                    'alter_tables_statement.properties.property.property_value.literal': 'table-props-value',
+                    'alter_cql_table_statement.properties.property.property_value.literal': 'table-props-value',
+
+                    'select_clause.projection.result_expr.expr.path.identifier_ref': 'columns',
+                    'export_statement.export_tables.export_table.column_name_list.column_name': 'columns',
+
+                    'consistency_statement.consistency': 'consistencies',
+                    'export_statement.export_to.export_database_type': 'export-database-types',
+                    'drop_export_database.export_database_name': 'export-databases',
+                    'use_export_db_statement.export_database_name': 'export-databases',
+                    'clean_up_export_session_statement.clean_up_export_sessions.export_session_name': 'export-sessions',
+                    'show_export_command.export_session_name': 'export-sessions',
+                    'import_statement.import_session.export_session_name': 'export-sessions-incomplete',
+                    'download_session_statement.export_session_name': 'export-sessions-incomplete',
+                } | bash_contexts | contexts_by_path
+            elif variant == 'l':
+                contexts_by_path = {
+                    'add_partition_action.partition_ref.partition_name': 'partition-columns',
+                    'show_topn_statement.topn_count': 'topn-counts',
+                    'show_topn_statement.topn_type': 'topn-types',
+                    'show_topn_statement.topn_window': 'topn-windows'
+                } | contexts_by_path
+            elif variant == 'x':
+                contexts_by_path = {
+                    'show_column_counts_command.path.identifier_ref': 'tables',
+                    'drop_export_database.export_database_name': 'export-databases',
+                    'use_export_db_statement.export_database_name': 'export-databases',
+                } | contexts_by_path
+
+                grammar = grammar.replace('select_clause: "SELECT"i hint_comment? projection', 'select_clause: ("SELECT"i | "XELECT"i) hint_comment? projection')
+
+            with offload():
+                with open('/tmp/grammar.lark', 'wt') as f:
+                    f.write(grammar)
+
+            return LarkParser(grammar, contexts_by_path)
+
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        if not self.nested and self.options_lambda:
+            # for lazy completions
+            self.nested = NestedCompleter.from_nested_dict(self.options_lambda())
+
+        nested_words = set()
+
+        if self.nested:
+            # from NestedCompleter
+
+            # Split document.
+            text = document.text_before_cursor.lstrip()
+            stripped_len = len(document.text_before_cursor) - len(text)
+
+            # If there is a space, check for the first term, and use a
+            # subcompleter.
+            if " " in text:
+                first_term = text.split()[0]
+                completer = self.nested.options.get(first_term)
+
+                # If we have a sub completer, use this for the completions.
+                if completer is not None:
+                    remaining_text = text[len(first_term) :].lstrip()
+                    move_cursor = len(text) - len(remaining_text) + stripped_len
+
+                    new_document = Document(
+                        remaining_text,
+                        cursor_position=document.cursor_position - move_cursor,
+                    )
+
+                    for c in completer.get_completions(new_document, complete_event):
+                        nested_words.add(c.text)
+                        yield c
+
+            # No space in the input: behave exactly like `WordCompleter`.
+            else:
+                completer = WordCompleter(
+                    list(self.nested.options.keys()), ignore_case=self.nested.ignore_case
+                )
+                for c in completer.get_completions(document, complete_event):
+                    nested_words.add(c.text)
+                    yield c
+
+        if self.parser:
+            full = document.text_before_cursor
+            if self.dml:
+                full = self.dml + ' ' + full
+
+            words0 = []
+            words1 = []
+            context = {}
+            for word in self.parser.next_terminals(full, context=context):
+                if ex := self.expandable(word):
+                    if ex in self.expandables:
+                        e = self.expandables[ex]
+                        if callable(e):
+                            if self.auto_complete(ex) != 'off':
+                                ctx = None
+                                if 'last-id' in context:
+                                    ctx = context['last-id']
+                                e = e(ctx)
+                                words0.extend(e)
+                        else:
+                            words0.extend(e)
+                else:
+                    words1.append(word)
+            words = words0 + words1
+
+            word_before_cursor = document.get_word_before_cursor(
+                WORD=self.WORD, pattern=self.pattern
+            )
+
+            word_before_cursor = word_before_cursor.lower()
+
+            def word_matches(word: str) -> bool:
+                return word.lower().startswith(word_before_cursor)
+
+            for word in words:
+                if word_matches(word) and word not in nested_words:
+                    display = self.display_dict.get(word, word)
+                    display_meta = self.meta_dict.get(word, "")
+                    yield Completion(
+                        word,
+                        -len(word_before_cursor),
+                        display=display,
+                        display_meta=display_meta,
+                    )
+
+    def completions_for_nesting(self, dml: str = None):
+        if dml:
+            return {dml: LarkCompleter(dml, expandables=self.expandables, variant=self.variant)}
+
+        return {
+            word.text.lower(): LarkCompleter(word.text, expandables=self.expandables, variant=self.variant)
+            for word in self.get_completions(Document(''), None)
+        }
+
+    def expandable(self, word: str):
+        return word.strip('`') if word.startswith('`') else None
+
+    def append_completions(self, key: str, value: dict[str, any]):
+        if isinstance(value, LarkCompleter) and self.variant == value.variant:
+            return
+
+        if self.nested:
+            self.nested = NestedCompleter.from_nested_dict(merge_completions(self.nested.options, value))
+        else:
+            self.nested = NestedCompleter.from_nested_dict(value)
+
+    def auto_complete(self, key: str, default = 'lazy'):
+        return Config().get(f'auto-complete.{self.variant}.{key}', default=default)