kaqing 2.0.49__tar.gz → 2.0.50__tar.gz

{kaqing-2.0.49 → kaqing-2.0.50}/PKG-INFO

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

kaqing-2.0.50/adam/commands/cql/cql_completions.py

@@ -0,0 +1,13 @@
+from adam.commands.cql.cql_table_completer import CqlTableNameCompleter
+from adam.commands.cql.cql_utils import table_names
+from adam.repl_state import ReplState
+from adam.sql.sql_completer import SqlCompleter
+
+def cql_completions(state: ReplState) -> dict[str, any]:
+    table_name_completer = CqlTableNameCompleter(table_names(state))
+    return {
+        'describe': {
+            'keyspaces': None,
+            'table': table_name_completer,
+            'tables': None},
+    } | SqlCompleter.completions(table_name_completer)

{kaqing-2.0.49 → kaqing-2.0.50}/adam/commands/cql/cql_table_completer.py

@@ -1,6 +1,6 @@
-from adam.table_completer import NestedDict, TableCompleter
+from adam.sql.table_name_completer import NestedDict, TableNameCompleter
 
-class CqlTableCompleter(TableCompleter):
+class CqlTableNameCompleter(TableNameCompleter):
     def __init__(self, tables: list[str], nested_dict: NestedDict = {}, ignore_case: bool = True):
         self._tables = tables
         self.ignore_case = ignore_case
@@ -9,8 +9,8 @@ class CqlTableCompleter(TableCompleter):
     def __repr__(self) -> str:
         return "CqlTableCompleter(%r)" % (len(self._tables))
 
-    def nested(self, data: NestedDict) -> 'TableCompleter':
-        return CqlTableCompleter(self._tables).append_nested_dict(data)
+    def nested(self, data: NestedDict) -> 'TableNameCompleter':
+        return CqlTableNameCompleter(self._tables).append_nested_dict(data)
 
     def tables(self) -> list[str]:
         return self._tables

{kaqing-2.0.49 → kaqing-2.0.50}/adam/commands/cql/cqlsh.py

@@ -55,6 +55,7 @@ class Cqlsh(Command):
 
     def completion(self, state: ReplState) -> dict[str, any]:
         if state.device != state.C:
+            # conflicts with psql completions
             return {}
 
         if state.sts or state.pod:

{kaqing-2.0.49 → kaqing-2.0.50}/adam/commands/medusa/medusa_restore.py

@@ -59,8 +59,7 @@ class MedusaRestore(Command):
         now_dtformat = datetime.now().strftime("%Y-%m-%d.%H.%M.%S")
         rtname = 'medusa-' + now_dtformat + '-restore-from-' + bkname
         try:
-            print('SEAN doing')
-            # CustomResources.create_medusa_restorejob(rtname, bkname, dc, ns)
+            CustomResources.create_medusa_restorejob(rtname, bkname, dc, ns)
         except Exception as e:
             log2("Exception: MedusaRestore failed: %s\n" % e)
 

{kaqing-2.0.49 → kaqing-2.0.50}/adam/commands/postgres/postgres.py

@@ -1,7 +1,7 @@
 import click
 
 from adam.commands.command import Command
-from adam.commands.postgres.pg_completions import pg_completions
+from adam.commands.postgres.psql_completions import psql_completions
 from adam.commands.postgres.postgres_utils import pg_table_names
 from .postgres_ls import PostgresLs
 from .postgres_preview import PostgresPreview
@@ -66,13 +66,14 @@ class Postgres(Command):
 
     def completion(self, state: ReplState):
         if state.device != state.P:
+            # conflicts with cql completions
             return {}
 
         leaf = {}
         session = PostgresSession(state.namespace, state.pg_path)
         if session.db:
           if pg_table_names(state.namespace, state.pg_path):
-            leaf = pg_completions(state.namespace, state.pg_path)
+            leaf = psql_completions(state.namespace, state.pg_path)
         elif state.pg_path:
             leaf = {
                 '\h': None,

kaqing-2.0.50/adam/commands/postgres/psql_completions.py

@@ -0,0 +1,11 @@
+from adam.commands.postgres.psql_table_completer import PsqlTableNameCompleter
+from adam.sql.sql_completer import SqlCompleter
+
+def psql_completions(ns: str, pg_path: str):
+    return {
+        '\h': None,
+        '\d': None,
+        '\dt': None,
+        '\du': None
+    } | SqlCompleter.completions(PsqlTableNameCompleter(ns, pg_path))
+    # } | PsqlTableCompleter(ns, pg_path).completions()

kaqing-2.0.50/adam/commands/postgres/psql_table_completer.py

@@ -0,0 +1,18 @@
+from adam.commands.postgres.postgres_utils import pg_table_names
+from adam.sql.table_name_completer import NestedDict, TableNameCompleter
+
+class PsqlTableNameCompleter(TableNameCompleter):
+    def __init__(self, namespace: str, pg_path: str, nested_dict: NestedDict = {}, ignore_case: bool = True):
+        self.namespace = namespace
+        self.pg_path = pg_path
+        self.ignore_case = ignore_case
+        self.append_nested_dict(nested_dict)
+
+    def __repr__(self) -> str:
+        return "PsqlTableCompleter(%r, pg_path=%r)" % (self.namespace, self.pg_path)
+
+    def nested(self, data: NestedDict) -> 'TableNameCompleter':
+        return PsqlTableNameCompleter(self.namespace, self.pg_path).append_nested_dict(data)
+
+    def tables(self) -> list[str]:
+        return pg_table_names(self.namespace, self.pg_path)

{kaqing-2.0.49 → kaqing-2.0.50}/adam/commands/preview_table.py

@@ -1,9 +1,9 @@
 import functools
 
 from adam.commands.command import Command
-from adam.commands.cql.cql_table_completer import CqlTableCompleter
+from adam.commands.cql.cql_table_completer import CqlTableNameCompleter
 from adam.commands.cql.cql_utils import run_cql, table_names, tables
-from adam.commands.postgres.pg_table_completer import PgTableCompleter
+from adam.commands.postgres.psql_table_completer import PsqlTableNameCompleter
 from adam.commands.postgres.postgres_session import PostgresSession
 from adam.config import Config
 from adam.repl_state import ReplState, RequiredState
@@ -73,9 +73,9 @@ class PreviewTable(Command):
 
     def completion(self, state: ReplState):
         if state.device == ReplState.P:
-            return {PreviewTable.COMMAND: PgTableCompleter(state.namespace, state.pg_path)}
+            return {PreviewTable.COMMAND: PsqlTableNameCompleter(state.namespace, state.pg_path)}
         elif state.sts:
-            return {PreviewTable.COMMAND: CqlTableCompleter(table_names(state))}
+            return {PreviewTable.COMMAND: CqlTableNameCompleter(table_names(state))}
 
         return {}
 

{kaqing-2.0.49 → kaqing-2.0.50}/adam/repl.py

@@ -18,6 +18,7 @@ from adam.log import Log
 from adam.repl_commands import ReplCommands
 from adam.repl_session import ReplSession
 from adam.repl_state import ReplState
+from adam.sql.sql_completer import SqlCompleter
 from adam.utils import deep_merge_dicts, deep_sort_dict, lines_to_tabular, log2
 from adam.apps import Apps
 from . import __version__
@@ -108,7 +109,7 @@ def enter_repl(state: ReplState):
                             log2(f'Timing auto-completion-calc {cmd.command()}: {time.time() - s1:.2f}')
 
                 # print(json.dumps(completions, indent=4))
-                completer = NestedCompleter.from_nested_dict(completions)
+                completer = SqlCompleter.from_nested_dict(completions)
 
             cmd = session.prompt(prompt_msg(), completer=completer, key_bindings=kb)
             s0 = time.time()

kaqing-2.0.49/adam/table_completer.py → kaqing-2.0.50/adam/sql/any_completer.py

@@ -1,16 +1,18 @@
-from abc import abstractmethod
 from typing import Any, Dict, Iterable, Mapping, Optional, Set, Union
 from prompt_toolkit.completion import CompleteEvent, Completer, Completion, NestedCompleter, WordCompleter
 from prompt_toolkit.document import Document
 
+from adam.sql.sql_utils import safe_terms
+
 NestedDict = Mapping[str, Union[Any, Set[str], None, Completer]]
 
-class TableCompleter(Completer):
-    def __init__(self, nested_dict: NestedDict = {}, ignore_case: bool = True):
+class AnyCompleter(Completer):
+    def __init__(self, default: str = None, nested_dict: NestedDict = {}, ignore_case: bool = True):
+        self.default = default
         self.ignore_case = ignore_case
         self.append_nested_dict(nested_dict)
 
-    def append_nested_dict(self, data: NestedDict) -> "TableCompleter":
+    def append_nested_dict(self, data: NestedDict) -> "AnyCompleter":
         options: Dict[str, Optional[Completer]] = {}
         for key, value in data.items():
             if isinstance(value, Completer):
@@ -33,18 +35,18 @@ class TableCompleter(Completer):
         text = document.text_before_cursor.lstrip()
         stripped_len = len(document.text_before_cursor) - len(text)
 
-        if " " in text:
+        terms, has_space = safe_terms(text)
+        if has_space:
             second_term = None
-            tokens = text.split()
-            if len(tokens) > 1:
-                second_term = tokens[1]
+            if len(terms) > 1:
+                second_term = terms[1]
 
             yielded = False
             if second_term:
                 completer = self.options.get(second_term)
 
                 if completer is not None:
-                    first_term = tokens[0]
+                    first_term = terms[0]
                     remaining_text = text[len(first_term) :].lstrip()
                     move_cursor = len(text) - len(remaining_text) + stripped_len
 
@@ -66,28 +68,17 @@ class TableCompleter(Completer):
                 )
                 for c in completer.get_completions(document, complete_event):
                     yield c
-        else:
-            completer = WordCompleter(
-                self.tables(), ignore_case=self.ignore_case
-            )
-            for c in completer.get_completions(document, complete_event):
+        elif words := self.words():
+            for c in words.get_completions(document, complete_event):
                 yield c
 
-    @abstractmethod
-    def nested(self, data: NestedDict) -> 'TableCompleter':
-        pass
-
-    @abstractmethod
-    def tables(self) -> list[str]:
-        pass
-
-    def completions(self):
-        return {
-            'delete': {'from': self.nested({'where': {'id': {'=': {"'id'": None}}}})},
-            'insert': {'into': self.nested({'values(': None})},
-            'select': {'*': {'from': self.nested({
-                'limit': {'1': {'where': {'id': {'=': {"'id'": None}}}}},
-                'where': {'id': {'=': {"'id'": {'limit': {'1': None}}}}}
-            })}},
-            'update': self.nested({'set': {'column': {'=': None}}}),
-        }
+    def words(self):
+        if not self.default:
+            return None
+
+        return WordCompleter(
+            [self.default], ignore_case=self.ignore_case
+        )
+
+    def nested(self, data: NestedDict) -> 'AnyCompleter':
+        return AnyCompleter(self.default).append_nested_dict(data)

kaqing-2.0.50/adam/sql/sql_completer.py

@@ -0,0 +1,53 @@
+from typing import Dict, Iterable, Optional
+from prompt_toolkit.completion import CompleteEvent, Completer, Completion, NestedCompleter, WordCompleter
+from prompt_toolkit.document import Document
+
+from adam.sql.any_completer import AnyCompleter as any
+from adam.sql.sql_utils import safe_terms
+from adam.sql.table_name_completer import TableNameCompleter
+
+class SqlCompleter(NestedCompleter):
+    def __init__(
+        self, options: Dict[str, Optional[Completer]], ignore_case: bool = True
+    ) -> None:
+        super().__init__(options, ignore_case)
+
+    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)
+
+        terms, has_space = safe_terms(text)
+        if has_space:
+            first_term = terms[0]
+            completer = self.options.get(first_term)
+
+            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):
+                    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
+
+    def completions(table: TableNameCompleter):
+        return {
+            'delete': {'from': table.nested({'where': any('id').nested({'=': any("'id'")})})},
+            'insert': {'into': table.nested({'values(': None})},
+            'select': any('*').nested({'from': table.nested({
+                'limit': any('1'),
+                'where': any('id').nested({'=': any("'id'").nested({'limit': any('1')})})
+            })}),
+            'update': table.nested({'set': {'column': {'=': None}}}),
+        }

kaqing-2.0.50/adam/sql/sql_utils.py

@@ -0,0 +1,5 @@
+import re
+
+def safe_terms(text: str):
+    tokens = re.findall(r'"[^"]+"|\b\w+\b|\S', text)
+    return tokens, len(tokens) > 1 or text.startswith(' ') or text.endswith(' ')

kaqing-2.0.50/adam/sql/table_name_completer.py

@@ -0,0 +1,17 @@
+from abc import abstractmethod
+from prompt_toolkit.completion import  WordCompleter
+
+from .any_completer import AnyCompleter, NestedDict
+
+class TableNameCompleter(AnyCompleter):
+    def __init__(self, nested_dict: NestedDict = {}, ignore_case: bool = True):
+        super().__init__(nested_dict=nested_dict, ignore_case=ignore_case)
+
+    def words(self):
+        return WordCompleter(
+            self.tables(), ignore_case=self.ignore_case
+        )
+
+    @abstractmethod
+    def tables(self) -> list[str]:
+        pass

kaqing-2.0.50/adam/version.py

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

{kaqing-2.0.49 → kaqing-2.0.50}/kaqing.egg-info/PKG-INFO

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

{kaqing-2.0.49 → kaqing-2.0.50}/kaqing.egg-info/SOURCES.txt

@@ -15,7 +15,6 @@ adam/repl.py
 adam/repl_commands.py
 adam/repl_session.py
 adam/repl_state.py
-adam/table_completer.py
 adam/utils.py
 adam/version.py
 adam/checks/__init__.py
@@ -110,13 +109,13 @@ adam/commands/medusa/medusa_restore.py
 adam/commands/medusa/medusa_show_backupjobs.py
 adam/commands/medusa/medusa_show_restorejobs.py
 adam/commands/postgres/__init__.py
-adam/commands/postgres/pg_completions.py
-adam/commands/postgres/pg_table_completer.py
 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/postgres/psql_completions.py
+adam/commands/postgres/psql_table_completer.py
 adam/commands/reaper/__init__.py
 adam/commands/reaper/reaper.py
 adam/commands/reaper/reaper_forward.py
@@ -166,6 +165,11 @@ adam/k8s_utils/service_accounts.py
 adam/k8s_utils/services.py
 adam/k8s_utils/statefulsets.py
 adam/k8s_utils/volumes.py
+adam/sql/__init__.py
+adam/sql/any_completer.py
+adam/sql/sql_completer.py
+adam/sql/sql_utils.py
+adam/sql/table_name_completer.py
 adam/sso/__init__.py
 adam/sso/authenticator.py
 adam/sso/authn_ad.py

{kaqing-2.0.49 → kaqing-2.0.50}/setup.py

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

kaqing-2.0.49/adam/commands/cql/cql_completions.py

@@ -1,12 +0,0 @@
-from adam.commands.cql.cql_table_completer import CqlTableCompleter
-from adam.commands.cql.cql_utils import table_names
-from adam.repl_state import ReplState
-
-def cql_completions(state: ReplState) -> dict[str, any]:
-    completer = CqlTableCompleter(table_names(state))
-    return {
-        'describe': {
-            'keyspaces': None,
-            'table': completer.completions(),
-            'tables': None},
-    } | completer.completions()

kaqing-2.0.49/adam/commands/postgres/pg_completions.py

@@ -1,9 +0,0 @@
-from adam.commands.postgres.pg_table_completer import PgTableCompleter
-
-def pg_completions(ns: str, pg_path: str):
-    return {
-        '\h': None,
-        '\d': None,
-        '\dt': None,
-        '\du': None
-    } | PgTableCompleter(ns, pg_path).completions()

kaqing-2.0.49/adam/commands/postgres/pg_table_completer.py

@@ -1,18 +0,0 @@
-from adam.commands.postgres.postgres_utils import pg_table_names
-from adam.table_completer import NestedDict, TableCompleter
-
-class PgTableCompleter(TableCompleter):
-    def __init__(self, namespace: str, pg_path: str, nested_dict: NestedDict = {}, ignore_case: bool = True):
-        self.namespace = namespace
-        self.pg_path = pg_path
-        self.ignore_case = ignore_case
-        self.append_nested_dict(nested_dict)
-
-    def __repr__(self) -> str:
-        return "PgTableCompleter(%r, pg_path=%r)" % (self.namespace, self.pg_path)
-
-    def nested(self, data: NestedDict) -> 'TableCompleter':
-        return PgTableCompleter(self.namespace, self.pg_path).append_nested_dict(data)
-
-    def tables(self) -> list[str]:
-        return pg_table_names(self.namespace, self.pg_path)

kaqing-2.0.49/adam/version.py

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