kaqing 2.0.93__py3-none-any.whl → 2.0.115__py3-none-any.whl

adam/commands/bash/bash.py

@@ -0,0 +1,124 @@
+from typing import Callable
+
+from adam.commands.bash.bash_completer import BashCompleter
+from adam.commands.command import Command
+from adam.utils_k8s.app_clusters import AppClusters
+from adam.utils_k8s.app_pods import AppPods
+from adam.utils_k8s.cassandra_clusters import CassandraClusters
+from adam.utils_k8s.cassandra_nodes import CassandraNodes
+from adam.pod_exec_result import PodExecResult
+from adam.repl_state import BashSession, ReplState, RequiredState
+from adam.utils_k8s.statefulsets import StatefulSets
+from build.lib.adam.utils_k8s.cassandra_nodes import CassandraNodes
+
+class Bash(Command):
+    COMMAND = 'bash'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Bash, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return Bash.COMMAND
+
+    def required(self):
+        return [RequiredState.CLUSTER_OR_POD, RequiredState.APP_APP]
+
+    def run(self, cmd: str, s0: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, s0)
+
+        state, args = self.apply_state(args, s0, args_to_check=2)
+        if not self.validate_state(state):
+            return state
+
+        def _run(state_changed: bool, cli: Callable[[str], None]):
+            if state.in_repl:
+                if state_changed:
+                    r = self.exec_with_dir(state, args)
+                else:
+                    r = self.exec_with_dir(s0, args)
+
+                if not r:
+                    state.exit_bash()
+
+                    return 'inconsistent pwd'
+
+                return r
+            else:
+                cli(' '.join(args))
+
+                return state
+
+        if state.device == ReplState.A:
+            def cli(command: str):
+                if state.app_pod:
+                    AppPods.exec(state.app_pod, state.namespace, command, show_out=True)
+                elif state.app_app:
+                    AppClusters.exec(AppPods.pod_names(state.namespace, state.app_env, state.app_app), state.namespace, command, action='bash', show_out=True)
+
+            return _run(s0.app_env != state.app_env or s0.app_app != state.app_app or s0.app_pod != state.app_pod, cli)
+
+        def cli(command: str):
+            if state.pod:
+                CassandraNodes.exec(state.pod, state.namespace, command, show_out=True)
+            elif state.sts:
+                CassandraClusters.exec(state.sts, state.namespace, command, action='bash', show_out=True)
+
+        return _run(s0.sts != state.sts or s0.pod != state.pod, cli)
+
+    def exec_with_dir(self, state: ReplState, args: list[str]) -> list[PodExecResult]:
+        session_just_created = False
+        if not args:
+            session_just_created = True
+            session = BashSession(state.device)
+            state.enter_bash(session)
+
+        if state.bash_session:
+            if args != ['pwd']:
+                if args:
+                    args.append('&&')
+                args.extend(['pwd', '>', f'/tmp/.qing-{state.bash_session.session_id}'])
+
+            if not session_just_created:
+                if pwd := state.bash_session.pwd(state):
+                    args = ['cd', pwd, '&&'] + args
+
+        command = ' '.join(args)
+
+        rs = []
+
+        if state.device == ReplState.A:
+            if state.app_pod:
+                rs = [AppPods.exec(state.app_pod, state.namespace, command,
+                                        show_out=not session_just_created, shell='bash')]
+            elif state.app_app:
+                rs = AppClusters.exec(AppPods.pod_names(state.namespace, state.app_env, state.app_app), state.namespace, command, action='bash',
+                                            show_out=not session_just_created, shell='bash')
+        else:
+            if state.pod:
+                rs = [CassandraNodes.exec(state.pod, state.namespace, command,
+                                        show_out=not session_just_created, shell='bash')]
+            elif state.sts:
+                rs = CassandraClusters.exec(state.sts, state.namespace, command, action='bash',
+                                            show_out=not session_just_created, shell='bash')
+
+        return rs
+
+    def completion(self, state: ReplState):
+        if state.device == ReplState.A and state.app_app:
+            return { Bash.COMMAND: BashCompleter(lambda: []) } | \
+                   {f'@{p}': {Bash.COMMAND: BashCompleter(lambda: [])} for p in AppPods.pod_names(state.namespace, state.app_env, state.app_app)}
+        elif state.sts:
+            return { Bash.COMMAND: BashCompleter(lambda: []) } | \
+                   {f'@{p}': {Bash.COMMAND: BashCompleter(lambda: [])} for p in StatefulSets.pod_names(state.sts, state.namespace)}
+
+        return {}
+
+    def help(self, _: ReplState):
+        return f'{Bash.COMMAND} [pod-name] [bash-commands] [&]\t run bash on the Cassandra nodes'

adam/commands/bash/bash_completer.py

@@ -0,0 +1,93 @@
+from typing import Callable
+from prompt_toolkit.completion import WordCompleter
+
+from adam.utils_repl.automata_completer import AutomataCompleter
+from adam.utils_repl.state_machine import State, StateMachine
+
+BASH_SPEC = [
+    # <command> ::= <simple_command> | <pipeline> | <conditional_command>
+    # <simple_command> ::= <word> <argument>* <redirection>*
+    # <pipeline> ::= <command> '|' <command>
+    # <conditional_command> ::= <command> '&&' <command> | <command> '||' <command>
+    # <word> ::= <letter> <letter_or_digit>*
+    # <argument> ::= <word>
+    # <redirection> ::= '>' <filename> | '<' <filename>
+    # <filename> ::= <word>
+    # <letter> ::= 'a' | 'b' | ... | 'z' | 'A' | 'B' | ... | 'Z'
+    # <digit> ::= '0' | '1' | ... | '9'
+    # <letter_or_digit> ::= <letter> | <digit>
+
+    '                                > word           > cmd                                ^ hosts',
+    'cmd                             > word           > cmd                                ^ |,>,2>,<,&,&&,||',
+    '-                               > pipe           > cmd_pipe',
+    '-                               > _rdr0_         > cmd_rdr0',
+    '-                               > _rdr1_         > cmd_rdr1',
+    '-                               > _rdr2_         > cmd_rdr2',
+    '-                               > &              > cmd_bg                             ^ |,>,2>,<,&,&&,||',
+    '-                               > &&|_or_        > nocmd',
+    'cmd_a                           > word           > cmd',
+    'cmd_pipe                        > word           > cmd',
+    'cmd_rdr0                        > word           > cmd_rdr0_f',
+    'cmd_rdr1                        > word           > cmd_rdr1_f',
+    'cmd_rdr2                        > word           > cmd_rdr2_f',
+    'cmd_rdr1_f                      > pipe           > cmd_pipe                           ^ |,2>,<,&,&&,||',
+    '-                               > _rdr2_         > cmd_rdr2',
+    '-                               > _rdr0_         > cmd_rdr0',
+    'cmd_rdr2_f                      > pipe           > cmd_pipe                           ^ |,<,&,&&,||',
+    '-                               > _rdr0_         > cmd_rdr0',
+    '-                               > &              > cmd_bg                             ^ |,>,2>,<,&,&&,||',
+    '-                               > &&|_or_        > nocmd',
+    'cmd_rdr0_f                      > pipe           > cmd_pipe                           ^ |,&,&&,||',
+    '-                               > &              > cmd_bg                             ^ |,>,2>,<,&,&&,||',
+    '-                               > &&|_or_        > cmd',
+    'cmd_bg                          > &&|_or_        > nocmd                              ^ &&,||',
+    'nocmd                           > word           > cmd',
+]
+
+BASH_KEYWORDS = [
+    '&',
+    '&&',
+    '|',
+    '||',
+    '>',
+    '2>',
+    '>>',
+    '<',
+    'hosts'
+]
+
+class BashStateMachine(StateMachine[str]):
+    def spec(self) -> str:
+        return BASH_SPEC
+
+    def keywords(self) -> list[str]:
+        return BASH_KEYWORDS
+
+class BashCompleter(AutomataCompleter[str]):
+    def __init__(self,
+                 hosts: Callable[[], list[str]],
+                 debug = False):
+        super().__init__(BashStateMachine(debug=debug), '', debug=debug)
+
+        self.hosts = hosts
+        self.debug = debug
+
+    def suggestions_completer(self, state: State, suggestions: str) -> list[str]:
+        if not suggestions:
+            return None
+
+        terms = []
+        for suggestion in suggestions.split(','):
+            terms.extend(self._terms(state, suggestion))
+
+        return WordCompleter(terms)
+
+    def _terms(self, _: State, word: str) -> list[str]:
+        terms = []
+
+        if word == 'hosts':
+            terms.extend(self.hosts())
+        else:
+            terms.append(word)
+
+        return terms

adam/commands/cat.py

@@ -0,0 +1,55 @@
+from adam.commands.bash.bash import Bash
+from adam.commands.command import Command
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log2
+from adam.utils_k8s.app_pods import AppPods
+from adam.utils_k8s.statefulsets import StatefulSets
+
+class Cat(Command):
+    COMMAND = 'cat'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Cat, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return Cat.COMMAND
+
+    def required(self):
+        return [RequiredState.CLUSTER_OR_POD, RequiredState.APP_APP]
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        state, args = self.apply_state(args, state)
+
+        if len(args) < 1:
+            if state.in_repl:
+                log2('File is required.')
+                log2()
+            else:
+                log2('* File is missing.')
+                Command.display_help()
+
+            return 'command-missing'
+
+        return Bash().run('bash ' + cmd, state)
+
+    def completion(self, state: ReplState):
+        if state.device == ReplState.A and state.app_app:
+            return super().completion(state) | \
+                {f'@{p}': {Cat.COMMAND: None} for p in AppPods.pod_names(state.namespace, state.app_env, state.app_app)}
+        elif state.device == ReplState.C and state.sts:
+            return super().completion(state) | \
+                {f'@{p}': {Cat.COMMAND: None} for p in StatefulSets.pod_names(state.sts, state.namespace)}
+
+        return {}
+
+    def help(self, _: ReplState):
+        return f'{Cat.COMMAND} file [&]\t run cat command on the Cassandra nodes'

adam/commands/cd.py

@@ -1,9 +1,10 @@
 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
-from adam.k8s_utils.statefulsets import StatefulSets
+from adam.commands.postgres.postgres_context import PostgresContext
+from adam.utils_k8s.app_pods import AppPods
+from adam.utils_k8s.cassandra_clusters import CassandraClusters
+from adam.utils_k8s.kube_context import KubeContext
+from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState
 from adam.utils import log2
 from adam.apps import Apps
@@ -23,10 +24,16 @@ class Cd(Command):
     def command(self):
         return Cd.COMMAND
 
+    def required(self):
+        return ReplState.NON_L
+
     def run(self, cmd: str, state: ReplState):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
+        if not self.validate_state(state):
+            return state
+
         if len(args) < 2:
             return state
 
@@ -36,22 +43,27 @@ class Cd(Command):
                 if dir == '':
                     state.pg_path = None
                 else:
-                    session = PostgresSession(state.namespace, state.pg_path)
+                    context: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path, arg=dir)
                     # patch up state.namespace from pg cd
-                    if not state.namespace and (ns := session.find_namespace(arg)):
-                        state.namespace = ns
-                    state.pg_path = session.directory(arg)
+                    if not state.namespace and context.namespace:
+                        state.namespace = context.namespace
+                    state.pg_path = context.path()
             elif state.device == ReplState.A:
                 if dir == '':
                     state.app_env = None
                     state.app_app = None
+                    state.app_pod = None
                 elif dir == '..':
-                    if state.app_app:
+                    if state.app_pod:
+                        state.app_pod = None
+                    elif state.app_app:
                         state.app_app = None
                     else:
                         state.app_env = None
                 else:
-                    if not state.app_env:
+                    if state.app_app:
+                        state.app_pod = dir
+                    elif not state.app_env:
                         tks = dir.split('@')
                         if len(tks) > 1:
                             state.namespace = tks[1]
@@ -91,16 +103,16 @@ class Cd(Command):
 
     def completion(self, state: ReplState):
         if state.device == ReplState.P:
-            pg = PostgresSession(state.namespace, state.pg_path) if state.pg_path else None
+            pg: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path) if state.pg_path else None
             if pg and pg.db:
                 return {Cd.COMMAND: {'..': None}}
             elif pg and pg.host:
-                return {Cd.COMMAND: {'..': None} | {p: None for p in pg_database_names(state.namespace, pg.directory())}}
+                return {Cd.COMMAND: {'..': None} | {p: None for p in pg_database_names(state.namespace, pg.path())}}
             else:
-                return {Cd.COMMAND: {p: None for p in PostgresSession.hosts(state.namespace)}}
+                return {Cd.COMMAND: {p: None for p in PostgresContext.hosts(state.namespace)}}
         elif state.device == ReplState.A:
             if state.app_app:
-                return {Cd.COMMAND: {'..': None}}
+                return {Cd.COMMAND: {'..': None} | {pod: None for pod in AppPods.pod_names(state.namespace, state.app_env, state.app_app)}}
             elif state.app_env:
                 return {Cd.COMMAND: {'..': None} | {app[0].split('-')[1]: None for app in Apps.apps(state.app_env)}}
             else:

adam/commands/check.py

@@ -23,11 +23,17 @@ class Check(Issues):
     def command(self):
         return Check.COMMAND
 
+    def required(self):
+        return ReplState.NON_L
+
     def run(self, cmd: str, state: ReplState):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
         state, args = self.apply_state(args, state)
+        if not self.validate_state(state):
+            return state
+
         args, show = Command.extract_options(args, ['-s', '--show'])
 
         if not args:

adam/commands/cli_commands.py

@@ -3,9 +3,9 @@ import re
 
 from adam.commands.reaper.reaper_session import ReaperSession
 from adam.config import Config
-from adam.k8s_utils.kube_context import KubeContext
-from adam.k8s_utils.secrets import Secrets
-from adam.k8s_utils.statefulsets import StatefulSets
+from adam.utils_k8s.kube_context import KubeContext
+from adam.utils_k8s.secrets import Secrets
+from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState
 
 class CliCommands:

adam/commands/code.py

@@ -0,0 +1,60 @@
+import code
+from functools import partial
+
+from adam.commands.command import Command
+from adam.commands.cql.cql_utils import cassandra_table_names, run_cql
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import lines_to_tabular
+from adam.utils_k8s.statefulsets import StatefulSets
+
+class Code(Command):
+    COMMAND = 'python'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Code, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return Code.COMMAND
+
+    def required(self):
+        return RequiredState.NAMESPACE
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        state, args = self.apply_state(args, state)
+        if not self.validate_state(state):
+            return state
+
+        sts = state.sts
+        pod = state.pod
+        pods = StatefulSets.pod_names(state.sts, state.namespace)
+        tables = cassandra_table_names(state)
+        cql = partial(run_cql, state, show_out=True)
+
+        my_local = globals() | locals()
+        # my_local = globals() | {'StatefulSets': StatefulSets} | locals()
+        lines = [
+            'sts: StatefulSet name',
+            'pod: Pod name',
+            'pods: Pod names in the current StatefulSet',
+            'tables: Cassandra tables names in the current StatefulSet',
+            "cql('select...'): run cql statement"
+        ]
+
+        code.interact(local=my_local, banner=lines_to_tabular(lines, header='Variables', separator=':'))
+
+        return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{Code.COMMAND} \t invoke interactive Python shell'

adam/commands/command.py

@@ -28,8 +28,10 @@ class Command:
 
         return None
 
-    def completion(self, _: ReplState, leaf: dict[str, any] = None) -> dict[str, any]:
-        # COMMAND = 'reaper activate schedule'
+    def completion(self, state: ReplState, leaf: dict[str, any] = None) -> dict[str, any]:
+        if not self.validate_state(state, show_err=False):
+            return {}
+
         d = leaf
         for t in reversed(self.command().split(' ')):
             d = {t: d}
@@ -39,8 +41,8 @@ class Command:
     def required(self) -> RequiredState:
         return None
 
-    def validate_state(self, state: ReplState, pg_required: RequiredState = None, app_required: RequiredState = None):
-        return state.validate(self.required(), pg_required=pg_required, app_required=app_required)
+    def validate_state(self, state: ReplState, show_err=True):
+        return state.validate(self.required(), show_err=show_err)
 
     def help(self, _: ReplState) -> str:
         return None
@@ -54,6 +56,9 @@ class Command:
         return a
 
     def apply_state(self, args: list[str], state: ReplState, resolve_pg = True, args_to_check = 6) -> tuple[ReplState, list[str]]:
+        """
+        Applies any contextual arguments such as namespace or statefulset to the ReplState and returns any non-contextual arguments.
+        """
         return state.apply_args(args, cmd=self.command_tokens(), resolve_pg=resolve_pg, args_to_check=args_to_check)
 
     def command_tokens(self):

adam/commands/commands_utils.py

@@ -1,16 +1,15 @@
 from concurrent.futures import ThreadPoolExecutor
-import time
 from kubernetes import client
 from typing import List
 
 from adam.checks.check_utils import run_checks
 from adam.columns.columns import Columns, collect_checks
 from adam.commands.issues import Issues
-from adam.k8s_utils.cassandra_nodes import CassandraNodes
-from adam.k8s_utils.pods import Pods
-from adam.k8s_utils.statefulsets import StatefulSets
+from adam.utils_k8s.cassandra_nodes import CassandraNodes
+from adam.utils_k8s.pods import Pods
+from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState
-from adam.utils import convert_seconds, duration, lines_to_tabular, log, log2
+from adam.utils import duration, lines_to_tabular, log, log2
 
 def show_pods(pods: List[client.V1Pod], ns: str, show_namespace = True, show_host_id = True):
     if len(pods) == 0:

adam/commands/cql/cql_completions.py

@@ -1,11 +1,15 @@
-from adam.commands.cql.cql_utils import table_names
+from adam.commands.cql.cql_utils import cassandra_table_names
+from adam.config import Config
 from adam.repl_state import ReplState
 from adam.sql.sql_completer import SqlCompleter
 
 def cql_completions(state: ReplState) -> dict[str, any]:
+    ps = Config().get('cql.alter-tables.gc-grace-periods', '3600,86400,864000,7776000').split(',')
     return {
         'describe': {
             'keyspaces': None,
-            'table': {t: None for t in table_names(state)},
+            'table': {t: None for t in cassandra_table_names(state)},
             'tables': None},
-    } | SqlCompleter.completions(lambda: table_names(state))
+    } | SqlCompleter(lambda: cassandra_table_names(state), table_props=lambda: {
+        'GC_GRACE_SECONDS': ps
+    }, variant='cql').completions_for_nesting()

adam/commands/cql/cql_utils.py

@@ -2,9 +2,9 @@ import functools
 import re
 
 from adam.config import Config
-from adam.k8s_utils.cassandra_clusters import CassandraClusters
-from adam.k8s_utils.cassandra_nodes import CassandraNodes
-from adam.k8s_utils.secrets import Secrets
+from adam.utils_k8s.cassandra_clusters import CassandraClusters
+from adam.utils_k8s.cassandra_nodes import CassandraNodes
+from adam.utils_k8s.secrets import Secrets
 from adam.pod_exec_result import PodExecResult
 from adam.repl_state import ReplState
 from adam.utils import log2
@@ -23,19 +23,28 @@ def keyspaces(state: ReplState, on_any=False):
 
     return parse_cql_desc_keyspaces(r.stdout if state.pod else r[0].stdout)
 
-def table_names(state: ReplState):
-    return [f'{k}.{t}' for k, ts in tables(state, on_any=True).items() for t in ts]
+def cassandra_table_names(state: ReplState, keyspace = None):
+    return [f'{k}.{t}' for k, ts in tables(state, on_any=True).items() for t in ts if not keyspace or k == keyspace]
 
 @functools.lru_cache()
-def tables(state: ReplState, on_any=False):
+def tables(state: ReplState, on_any=False) -> dict[str, list[str]]:
     r: list[PodExecResult] = run_cql(state, 'describe tables', show_out=False, on_any=on_any)
     if not r:
         log2('No pod is available')
-        return []
+        return {}
 
     return parse_cql_desc_tables(r.stdout if state.pod else r[0].stdout)
 
-def run_cql(state: ReplState, cql: str, opts: list = [], show_out = False, use_single_quotes = False, on_any = False):
+@functools.lru_cache()
+def table_spec(state: ReplState, table: str, on_any=False) -> 'TableSpec':
+    r: list[PodExecResult] = run_cql(state, f'describe table {table}', show_out=False, on_any=on_any)
+    if not r:
+        log2('No pod is available')
+        return None
+
+    return parse_cql_desc_table(r.stdout if state.pod else r[0].stdout)
+
+def run_cql(state: ReplState, cql: str, opts: list = [], show_out = False, use_single_quotes = False, on_any = False, background=False) -> list[PodExecResult]:
     user, pw = Secrets.get_user_pass(state.sts if state.sts else state.pod, state.namespace, secret_path='cql.secret')
     if use_single_quotes:
         command = f"cqlsh -u {user} -p {pw} {' '.join(opts)} -e '{cql}'"
@@ -43,9 +52,9 @@ def run_cql(state: ReplState, cql: str, opts: list = [], show_out = False, use_s
         command = f'cqlsh -u {user} -p {pw} {" ".join(opts)} -e "{cql}"'
 
     if state.pod:
-        return CassandraNodes.exec(state.pod, state.namespace, command, show_out=show_out)
+        return CassandraNodes.exec(state.pod, state.namespace, command, show_out=show_out, background=background)
     else:
-        return CassandraClusters.exec(state.sts, state.namespace, command, show_out=show_out, action='cql', on_any=on_any)
+        return CassandraClusters.exec(state.sts, state.namespace, command, show_out=show_out, action='cql', on_any=on_any, background=background)
 
 def parse_cql_desc_tables(out: str):
     # Keyspace data_endpoint_auth
@@ -109,4 +118,87 @@ def parse_cql_desc_keyspaces(out: str) -> list[str]:
             if s := ks.strip(' \r\t'):
                 kses.append(s)
 
-    return kses
+    return kses
+
+class ColumnSpec:
+    def __init__(self, name: str, type: str, key_index = -1):
+        self.name = name
+        self.type = type
+        self.key_index = key_index
+
+    def __eq__(self, other):
+        if not isinstance(other, ColumnSpec):
+            return NotImplemented  # Or raise TypeError, depending on desired strictness
+
+        # Then, compare the relevant attributes for equality
+        return self.name == other.name and self.type == other.type and self.key_index == other.key_index
+
+class TableSpec:
+    def __init__(self, columns: list[ColumnSpec]):
+        self.columns = columns
+
+    def row_key(self):
+        for c in self.columns:
+            if c.key_index == 0:
+                return c.name
+
+    def keys(self):
+        return [c.name for c in self.columns if c.key_index > -1]
+
+def parse_cql_desc_table(out: str) -> TableSpec:
+    # CREATE TABLE azops88_db.analyticscontainer_dfeevalhistory (
+    #     id text,
+    #     columnname text,
+    #     version bigint static,
+    #     contentb blob,
+    #     contentbool boolean,
+    #     contentn double,
+    #     contents text,
+    #     PRIMARY KEY (id, columnname)
+    # ) WITH CLUSTERING ORDER BY (columnname ASC)
+    #     AND additional_write_policy = '99p'
+    #     AND bloom_filter_fp_chance = 0.1
+    #     AND caching = {'keys': 'ALL', 'rows_per_partition': 'NONE'}
+    #     AND cdc = false
+    #     AND comment = ''
+    #     AND compaction = {'class': 'org.apache.cassandra.db.compaction.LeveledCompactionStrategy', 'max_threshold': '32', 'min_threshold': '4'}
+    #     AND compression = {'chunk_length_in_kb': '16', 'class': 'org.apache.cassandra.io.compress.SnappyCompressor'}
+    #     AND memtable = 'default'
+    #     AND crc_check_chance = 1.0
+    #     AND default_time_to_live = 0
+    #     AND extensions = {}
+    #     AND gc_grace_seconds = 3600
+    #     AND max_index_interval = 2048
+    #     AND memtable_flush_period_in_ms = 0
+    #     AND min_index_interval = 128
+    #     AND read_repair = 'BLOCKING'
+    #     AND speculative_retry = '99p';
+    pkeys = {}
+    columns: list[ColumnSpec] = []
+
+    state = 's0'
+    for line in out.split('\n'):
+        if state == 's0':
+            if line.startswith('CREATE TABLE'):
+                state = 's1'
+        elif state == 's1':
+            if line.startswith(')'):
+                state = 's2'
+                continue
+
+            groups = re.match(r'^\s*PRIMARY KEY\s*\((.*)\).*$', line)
+            if groups:
+                pkeys = {n.strip(' '): i for i, n in enumerate(groups[1].strip(' \r').split(','))}
+                continue
+
+            groups = re.match(r'^\s*(\S*?)\s*(\S*?),.*$', line)
+            if groups:
+                columns.append(ColumnSpec(groups[1], groups[2]))
+        elif state == 's2':
+            pass
+
+    for column in columns:
+        if column.name in pkeys.keys():
+            column.key_index = pkeys[column.name]
+
+    return TableSpec(columns)