kaqing 2.0.41__tar.gz → 2.0.43__tar.gz

{kaqing-2.0.41 → kaqing-2.0.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kaqing
-Version: 2.0.41
+Version: 2.0.43
 Summary: UNKNOWN
 Home-page: UNKNOWN
 License: UNKNOWN

{kaqing-2.0.41 → kaqing-2.0.43}/adam/commands/cd.py

@@ -1,4 +1,5 @@
 from adam.commands.command import Command
+from adam.commands.postgres.postgres_utils import pg_database_names
 from adam.commands.postgres.postgres_session import PostgresSession
 from adam.k8s_utils.cassandra_clusters import CassandraClusters
 from adam.k8s_utils.kube_context import KubeContext
@@ -91,7 +92,7 @@ class Cd(Command):
             if pg and pg.db:
                 return {Cd.COMMAND: {'..': None}}
             elif pg and pg.host:
-                return {Cd.COMMAND: {'..': None} | {p['name']: None for p in pg.databases()}}
+                return {Cd.COMMAND: {'..': None} | {p: None for p in pg_database_names(state.namespace, pg.directory())}}
             else:
                 return {Cd.COMMAND: {p: None for p in PostgresSession.hosts(state.namespace)}}
         elif state.device == ReplState.A:

{kaqing-2.0.41 → kaqing-2.0.43}/adam/commands/cql_utils.py

@@ -11,7 +11,7 @@ from adam.utils import log2
 
 @functools.lru_cache()
 def keyspaces(state: ReplState, on_any=False):
-    Config().wait_log("Inspecting Cassandra Keyspaces...")
+    Config().wait_log('Inspecting Cassandra Keyspaces...')
 
     r: list[PodExecResult] = run_cql(state, 'describe keyspaces', show_out=False, on_any=on_any)
     if not r:

{kaqing-2.0.41 → kaqing-2.0.43}/adam/commands/ls.py

@@ -1,15 +1,14 @@
 import copy
-import re
 
 from adam.commands.command import Command
 from adam.commands.commands_utils import show_pods, show_rollout
 from adam.commands.cqlsh import Cqlsh
+from adam.commands.postgres.postgres_utils import pg_database_names, pg_table_names
 from adam.commands.postgres.postgres_session import PostgresSession
 from adam.config import Config
 from adam.k8s_utils.custom_resources import CustomResources
 from adam.k8s_utils.ingresses import Ingresses
 from adam.k8s_utils.kube_context import KubeContext
-from adam.k8s_utils.services import Services
 from adam.k8s_utils.statefulsets import StatefulSets
 from adam.pod_exec_result import PodExecResult
 from adam.repl_state import ReplState
@@ -123,14 +122,10 @@ class Ls(Command):
             log(lines_to_tabular(lines, 'NAME,NAMESPACE,ENDPOINT,USERNAME,PASSWORD', separator=','))
 
     def show_pg_databases(self, pg: PostgresSession):
-        lines = [db["name"] for db in pg.databases() if db["owner"] == PostgresSession.default_owner()]
-
-        log(lines_to_tabular(lines, 'DATABASE', separator=','))
+        log(lines_to_tabular(pg_database_names(pg.namespace, pg.directory()), 'DATABASE', separator=','))
 
     def show_pg_tables(self, pg: PostgresSession):
-        lines = [db["name"] for db in pg.tables() if db["schema"] == PostgresSession.default_schema()]
-
-        log(lines_to_tabular(lines, 'NAME', separator=','))
+        log(lines_to_tabular(pg_table_names(pg.namespace, pg.directory()), 'NAME', separator=','))
 
     def completion(self, state: ReplState):
         if state.pod:

{kaqing-2.0.41 → kaqing-2.0.43}/adam/commands/postgres/postgres.py

@@ -2,6 +2,7 @@ import functools
 import click
 
 from adam.commands.command import Command
+from adam.commands.postgres.postgres_utils import pg_table_names
 from .postgres_ls import PostgresLs
 from .postgres_preview import PostgresPreview
 from .postgres_session import PostgresSession
@@ -67,19 +68,20 @@ class Postgres(Command):
         leaf = {}
         session = PostgresSession(state.namespace, state.pg_path)
         if session.db:
-            ts = self.tables(state.namespace, state.pg_path)
+          if pg_table_names(state.namespace, state.pg_path):
+            ts = f'<pg_tables:{state.namespace}:{state.pg_path}>'
             leaf = {
                 '\h': None,
                 '\d': None,
                 '\dt': None,
                 '\du': None,
-                'delete': {'from': {t: {'where': {'id': {'=': None}}} for t in ts}},
-                'insert': {'into': {t: {'values': None} for t in ts}},
-                'select': {'*': {'from': {t: {
+                'delete': {'from': {ts: {'where': {'id': {'=': None}}}}},
+                'insert': {'into': {ts: {'values': None}}},
+                'select': {'*': {'from': {ts: {
                     'limit': {'1': None},
                     'where': {'id': {'=': None}}
-                } for t in ts}}},
-                'update': {t: {'set': None} for t in ts},
+                }}}},
+                'update': {ts: {'set': None}},
             }
         elif state.pg_path:
             leaf = {
@@ -92,15 +94,6 @@ class Postgres(Command):
         else:
             return {}
 
-    # TODO fix cache
-    # @functools.lru_cache()
-    def tables(self, ns: str, pg_path: str):
-        session = PostgresSession(ns, pg_path)
-        if session.db:
-            return [f'{t["schema"]}.{t["name"]}' for t in session.tables()]
-
-        return []
-
     def help(self, _: ReplState):
         return f'[{Postgres.COMMAND}] <sql-statements>\t run psql with queries'
 

{kaqing-2.0.41 → kaqing-2.0.43}/adam/commands/postgres/postgres_session.py

@@ -25,13 +25,6 @@ class PostgresSession:
             if len(tks) > 1:
                 self.db = tks[1]
 
-    # works only for databases()
-    def __eq__(self, other: 'PostgresSession'):
-        return self.host == other.host
-
-    def __hash__(self):
-        return hash(self.host)
-
     def find_namespace(self, arg: str):
         if arg:
             tks = arg.split('@')
@@ -82,7 +75,6 @@ class PostgresSession:
 
         return [s for s in ss if not excludes(s)]
 
-    @functools.lru_cache()
     def databases(self):
         dbs = []
         #  List of databases

kaqing-2.0.43/adam/commands/postgres/postgres_utils.py

@@ -0,0 +1,23 @@
+import functools
+
+from adam.commands.postgres.postgres_session import PostgresSession
+from adam.config import Config
+
+@functools.lru_cache()
+def pg_database_names(ns: str, pg_path: str):
+    Config().wait_log('Inspecting Postgres Databases...')
+
+    pg = PostgresSession(ns, pg_path)
+    return [db['name'] for db in pg.databases() if db['owner'] == PostgresSession.default_owner()]
+
+@functools.lru_cache()
+def pg_table_names(ns: str, pg_path: str):
+    Config().wait_log('Inspecting Postgres Database...')
+    return [table['name'] for table in pg_tables(ns, pg_path) if table['schema'] == PostgresSession.default_schema()]
+
+def pg_tables(ns: str, pg_path: str):
+    pg = PostgresSession(ns, pg_path)
+    if pg.db:
+        return pg.tables()
+
+    return []

{kaqing-2.0.41 → kaqing-2.0.43}/adam/commands/preview_table.py

@@ -4,7 +4,6 @@ from adam.commands.command import Command
 from adam.commands.cql_utils import run_cql, tables
 from adam.commands.postgres.postgres_session import PostgresSession
 from adam.config import Config
-from adam.pod_exec_result import PodExecResult
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import lines_to_tabular, log, log2
 
@@ -72,8 +71,7 @@ class PreviewTable(Command):
 
     def completion(self, state: ReplState):
         if state.device == ReplState.P:
-            if tables := PreviewTable.pg_tables(state.namespace, state.pg_path):
-                return {PreviewTable.COMMAND: {db["name"]: None for db in tables if db["schema"] == PostgresSession.default_schema()}}
+            return {PreviewTable.COMMAND: {f'<pg_tables:{state.namespace}:{state.pg_path}>': None}}
         elif state.sts:
             tables = PreviewTable.cql_tables(state)
             return {PreviewTable.COMMAND: {f'{k}.{t}': None for k, ts in tables.items() for t in ts}}
@@ -88,18 +86,4 @@ class PreviewTable(Command):
         if state.pod:
             return tables(state)
 
-        return tables(state, on_any=True)
-
-        # r: list[PodExecResult] = run_cql(state, 'describe tables', show_out=False, on_any=True)
-        # if not r:
-        #     return []
-
-        # return parse_cql_desc_tables(r[0].stdout)
-
-    @functools.lru_cache()
-    def pg_tables(ns: str, pg_path: str):
-        pg = PostgresSession(ns, pg_path)
-        if pg.db:
-            return pg.tables()
-
-        return None
+        return tables(state, on_any=True)

{kaqing-2.0.41 → kaqing-2.0.43}/adam/commands/reaper/reaper_session.py

@@ -149,7 +149,7 @@ class ReaperSession:
             return ReaperSession.schedules_ids_by_cluster[state.sts]
 
         if reaper := ReaperSession.create(state):
-            Config().wait_log("Inspecting Cassandra Reaper...")
+            Config().wait_log('Inspecting Cassandra Reaper...')
 
             schedules = reaper.schedule_ids(state, show_output = False)
             ReaperSession.schedules_ids_by_cluster[state.sts] = schedules

{kaqing-2.0.41 → kaqing-2.0.43}/adam/k8s_utils/statefulsets.py

@@ -24,6 +24,7 @@ class StatefulSets:
 
         return statefulsets.items
 
+    @functools.lru_cache()
     def list_sts_name_and_ns():
         return [(statefulset.metadata.name, statefulset.metadata.namespace) for statefulset in StatefulSets.list_sts()]
 

{kaqing-2.0.41 → kaqing-2.0.43}/adam/repl.py

@@ -1,3 +1,4 @@
+import json
 import os
 import re
 import time
@@ -16,6 +17,7 @@ from adam.k8s_utils.kube_context import KubeContext
 from adam.k8s_utils.statefulsets import StatefulSets
 from adam.log import Log
 from adam.repl_commands import ReplCommands
+from adam.repl_completer import CompleterContext, ReplCompleter
 from adam.repl_session import ReplSession
 from adam.repl_state import ReplState
 from adam.utils import deep_merge_dicts, deep_sort_dict, lines_to_tabular, log2
@@ -92,7 +94,7 @@ def enter_repl(state: ReplState):
     sorted_cmds = sorted(cmd_list, key=lambda cmd: cmd.command())
     while True:
         try:
-            completer = NestedCompleter.from_nested_dict({})
+            completer = ReplCompleter.from_nested_dict({})
             if not state.bash_session:
                 completions = {}
                 # app commands are available only on a: drive
@@ -105,9 +107,10 @@ def enter_repl(state: ReplState):
                         completions = deep_sort_dict(deep_merge_dicts(completions, cmd.completion(state)))
                     finally:
                         if Config().get('debugs.timings', False):
-                            Config().debug('Timing completion calc', cmd.command(), f'{time.time() - s1:.2f}')
+                            log2(f'Timing auto-completion-calc {cmd.command()}: {time.time() - s1:.2f}')
 
-                completer = NestedCompleter.from_nested_dict(completions)
+                # print(json.dumps(completions, indent=4))
+                completer = ReplCompleter.from_nested_dict(completions)
 
             cmd = session.prompt(prompt_msg(), completer=completer, key_bindings=kb)
             s0 = time.time()
@@ -151,9 +154,10 @@ def enter_repl(state: ReplState):
                 log2(e)
                 Config().debug(traceback.format_exc())
         finally:
+            CompleterContext().reset()
             Config().clear_wait_log_flag()
             if Config().get('debugs.timings', False) and 'cmd' in locals() and 's0' in locals():
-                print('Timing command', cmd, f'{time.time() - s0:.2f}')
+                log2(f'Timing command {cmd}: {time.time() - s0:.2f}')
 
 @cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=ClusterCommandHelper, help="Enter interactive shell.")
 @click.option('--kubeconfig', '-k', required=False, metavar='path', help='path to kubeconfig file')

kaqing-2.0.43/adam/repl_completer.py

@@ -0,0 +1,74 @@
+import re
+
+from typing import Iterable
+from prompt_toolkit.completion import CompleteEvent, Completion, NestedCompleter, WordCompleter
+from prompt_toolkit.document import Document
+
+from adam.commands.postgres.postgres_utils import pg_table_names
+
+class CompleterContext:
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(CompleterContext, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self):
+        if not hasattr(self, 'table_resolver'):
+            self.table_resolver = None
+            self.tables = []
+
+    def produce(self, word: str):
+        if match := re.match(r'^<pg_tables:(.*?):(.*?)>$', word):
+            self.table_resolver = word
+            self.tables = pg_table_names(match.group(1), match.group(2))
+
+            return self.tables
+
+        return None
+
+    def is_table(self, word: str):
+        if word in self.tables and self.table_resolver:
+            return self.table_resolver
+
+        return None
+
+    def reset(self):
+        self.table_resolver = None
+        self.tables = []
+
+
+class ReplCompleter(NestedCompleter):
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        text = document.text_before_cursor.lstrip()
+        stripped_len = len(document.text_before_cursor) - len(text)
+
+        if " " in text:
+            first_term = text.split()[0]
+            completer = self.options.get(first_term)
+            if table_resolver := CompleterContext().is_table(first_term):
+                completer = self.options.get(table_resolver)
+
+            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):
+                    if words := CompleterContext().produce(c.text):
+                        for w in words:
+                            yield Completion(w)
+                    else:
+                        yield c
+        else:
+            completer = WordCompleter(
+                list(self.options.keys()), ignore_case=self.ignore_case
+            )
+            for c in completer.get_completions(document, complete_event):
+                yield c

kaqing-2.0.43/adam/version.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+__version__ = "2.0.43"  #: the working version
+__release__ = "1.0.0"  #: the release version

{kaqing-2.0.41 → kaqing-2.0.43}/kaqing.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kaqing
-Version: 2.0.41
+Version: 2.0.43
 Summary: UNKNOWN
 Home-page: UNKNOWN
 License: UNKNOWN

{kaqing-2.0.41 → kaqing-2.0.43}/kaqing.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ adam/log.py
 adam/pod_exec_result.py
 adam/repl.py
 adam/repl_commands.py
+adam/repl_completer.py
 adam/repl_session.py
 adam/repl_state.py
 adam/utils.py
@@ -110,6 +111,7 @@ adam/commands/postgres/postgres.py
 adam/commands/postgres/postgres_ls.py
 adam/commands/postgres/postgres_preview.py
 adam/commands/postgres/postgres_session.py
+adam/commands/postgres/postgres_utils.py
 adam/commands/reaper/__init__.py
 adam/commands/reaper/reaper.py
 adam/commands/reaper/reaper_forward.py

{kaqing-2.0.41 → kaqing-2.0.43}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='kaqing',
-    version='2.0.41',
+    version='2.0.43',
     packages=find_packages(),
     entry_points={
         'console_scripts': [

kaqing-2.0.41/adam/version.py

@@ -1,5 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-__version__ = "2.0.41"  #: the working version
-__release__ = "1.0.0"  #: the release version