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

adam/commands/audit/audit_run.py

@@ -1,5 +1,3 @@
-import concurrent
-
 from adam.commands.command import Command
 from adam.config import Config
 from adam.repl_state import ReplState
@@ -30,29 +28,23 @@ class AuditRun(Command):
         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
-
-        meta: AuditMeta = Audits.get_meta()
-        clusters = Audits.find_new_clusters(meta.cluster_last_checked)
-        Audits.put_meta(Audits.ADD_CLUSTERS, meta, clusters=clusters)
-        if clusters:
-            log2(f'Added {len(clusters)} new clusters.')
-            tables = Config().get('audit.athena.repair-cluster-tables', 'cluster').split(',')
-            with concurrent.futures.ThreadPoolExecutor(max_workers=Config().get('audit.workers', 3)) as executor:
-                for table in tables:
-                    executor.submit(Athena.run_query, f'MSCK REPAIR TABLE {table}', None,)
-        else:
-            log2(f'No new clusters were found.')
+        with self.validate(args, state) as (args, state):
+            meta: AuditMeta = Audits.get_meta()
+            clusters = Audits.find_new_clusters(meta.cluster_last_checked)
+            Audits.put_meta(Audits.ADD_CLUSTERS, meta, clusters=clusters)
+            if clusters:
+                log2(f'Added {len(clusters)} new clusters.')
+                tables = Config().get('audit.athena.repair-cluster-tables', 'cluster').split(',')
+                with Audits.offload() as exec:
+                    for table in tables:
+                        exec.submit(Athena.query, f'MSCK REPAIR TABLE {table}', None,)
+            else:
+                log2(f'No new clusters were found.')
 
-        return state
+            return state
 
     def completion(self, state: ReplState):
-        if state.device == ReplState.L:
-            return super().completion(state)
-
-        return {}
+        return super().completion(state)
 
     def help(self, _: ReplState):
-        return f"{AuditRun.COMMAND} \t run"
+        return f"{AuditRun.COMMAND}\t run"

adam/commands/audit/show_last10.py

@@ -27,21 +27,18 @@ class ShowLast10(Command):
         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
-
-        limit, date_condition = extract_limit_and_duration(args)
+        with self.validate(args, state) as (args, state):
+            limit, date_condition = extract_limit_and_duration(args)
 
-        query = '\n    '.join([
-            "SELECT * FROM audit",
-            f"WHERE drive <> 'z' and ({date_condition})",
-            f"ORDER BY ts DESC LIMIT {limit};"])
-        log2(query)
-        log2()
-        Athena.run_query(query)
+            query = '\n    '.join([
+                "SELECT * FROM audit",
+                f"WHERE drive <> 'z' and ({date_condition})",
+                f"ORDER BY ts DESC LIMIT {limit};"])
+            log2(query)
+            log2()
+            Athena.run_query(query)
 
-        return state
+            return state
 
     def completion(self, _: ReplState):
 

adam/commands/audit/show_slow10.py

@@ -27,21 +27,18 @@ class ShowSlow10(Command):
         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
-
-        limit, date_condition = extract_limit_and_duration(args)
+        with self.validate(args, state) as (args, state):
+            limit, date_condition = extract_limit_and_duration(args)
 
-        query = '\n    '.join([
-            "SELECT * FROM audit",
-            f"WHERE drive <> 'z' and ({date_condition})",
-            f"ORDER BY CAST(duration AS REAL) DESC LIMIT {limit};"])
-        log2(query)
-        log2()
-        Athena.run_query(query)
+            query = '\n    '.join([
+                "SELECT * FROM audit",
+                f"WHERE drive <> 'z' and ({date_condition})",
+                f"ORDER BY CAST(duration AS REAL) DESC LIMIT {limit};"])
+            log2(query)
+            log2()
+            Athena.run_query(query)
 
-        return state
+            return state
 
     def completion(self, _: ReplState):
         return {}

adam/commands/audit/show_top10.py

@@ -3,7 +3,6 @@ from adam.commands.command import Command
 from adam.repl_state import ReplState
 from adam.utils import log2
 from adam.utils_athena import Athena
-from adam.utils_audits import Audits
 
 class ShowTop10(Command):
     COMMAND = 'show top'
@@ -27,20 +26,17 @@ class ShowTop10(Command):
         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
-
-        limit, date_condition = extract_limit_and_duration(args)
-        query = '\n    '.join([
-            "SELECT min(c) AS cluster, line, COUNT(*) AS cnt, avg(CAST(duration AS REAL)) AS duration",
-            f"FROM audit WHERE drive <> 'z' and ({date_condition})",
-            f"GROUP BY line ORDER BY cnt DESC LIMIT {limit};"])
-        log2(query)
-        log2()
-        Athena.run_query(query)
+        with self.validate(args, state) as (args, state):
+            limit, date_condition = extract_limit_and_duration(args)
+            query = '\n    '.join([
+                "SELECT min(c) AS cluster, line, COUNT(*) AS cnt, avg(CAST(duration AS REAL)) AS duration",
+                f"FROM audit WHERE drive <> 'z' and ({date_condition})",
+                f"GROUP BY line ORDER BY cnt DESC LIMIT {limit};"])
+            log2(query)
+            log2()
+            Athena.run_query(query)
 
-        return state
+            return state
 
     def completion(self, _: ReplState):
         return {}

adam/commands/audit/utils_show_top10.py

@@ -1,5 +1,6 @@
 from datetime import datetime, timedelta
 
+from adam.utils import log_exc
 from adam.utils_audits import Audits
 from adam.utils_repl.automata_completer import AutomataCompleter
 from adam.utils_repl.state_machine import StateMachine
@@ -8,10 +9,8 @@ def extract_limit_and_duration(args: list[str]) -> tuple[int, datetime]:
     limit = 10
     _from = datetime.now() - timedelta(days=30)
     if args:
-        try:
+        with log_exc():
             limit = int(args[0])
-        except:
-            pass
 
         if len(args) > 2 and args[1] == 'over':
             if args[2] == 'day':

adam/commands/bash/__init__.py

@@ -0,0 +1,5 @@
+from adam.commands.bash.utils_bash import BashHandler
+from adam.repl_state import ReplState
+
+def bash(s0: ReplState, s1: ReplState):
+    return BashHandler(s0, s1)

adam/commands/bash/bash.py

@@ -1,15 +1,7 @@
-from typing import Callable
-
-from adam.commands.bash.bash_completer import BashCompleter
+from adam.commands.bash import bash
 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
+from adam.commands.devices.devices import Devices
+from adam.repl_state import ReplState, RequiredState
 
 class Bash(Command):
     COMMAND = 'bash'
@@ -27,98 +19,18 @@ class Bash(Command):
         return Bash.COMMAND
 
     def required(self):
-        return [RequiredState.CLUSTER_OR_POD, RequiredState.APP_APP]
+        return [RequiredState.CLUSTER_OR_POD, RequiredState.APP_APP, ReplState.P]
 
     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
+        with self.validate(args, s0) as (args, s1):
+            with bash(s0, s1) as exec:
+                return exec(args)
 
     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 {}
+        return Devices.device(state).bash_completion(Bash.COMMAND, state, default = {})
 
     def help(self, _: ReplState):
         return f'{Bash.COMMAND} [pod-name] [bash-commands] [&]\t run bash on the Cassandra nodes'

adam/commands/bash/utils_bash.py

@@ -0,0 +1,16 @@
+from adam.commands.devices.devices import Devices
+from adam.repl_state import ReplState
+
+class BashHandler:
+    def __init__(self, s0: ReplState, s1: ReplState):
+        self.s0 = s0
+        self.s1 = s1
+
+    def __enter__(self):
+        return self.exec
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+    def exec(self, args: list[str]):
+        return Devices.device(self.s1).bash(self.s0, self.s1, args)

adam/commands/cat.py

@@ -1,5 +1,5 @@
-from adam.commands.bash.bash import Bash
 from adam.commands.command import Command
+from adam.commands.devices.devices import Devices
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log2
 from adam.utils_k8s.app_pods import AppPods
@@ -21,33 +21,28 @@ class Cat(Command):
         return Cat.COMMAND
 
     def required(self):
-        return [RequiredState.CLUSTER_OR_POD, RequiredState.APP_APP]
+        return [RequiredState.CLUSTER_OR_POD, RequiredState.APP_APP, ReplState.P]
 
     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)
+        with self.validate(args, state) as (args, state):
+            if len(args) < 1:
+                if state.in_repl:
+                    log2('File is required.')
+                    log2()
+                else:
+                    log2('* File is missing.')
+                    Command.display_help()
 
-        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 'command-missing'
-
-        return Bash().run('bash ' + cmd, state)
+            return Devices.device(state).cat(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)}
+        if super().completion(state):
+            return Devices.device(state).cat_completion(Cat.COMMAND, state, default={})
 
         return {}
 

adam/commands/cd.py

@@ -1,13 +1,7 @@
 from adam.commands.command import Command
-from adam.commands.postgres.postgres_utils import pg_database_names
-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.commands.devices.device import Device
+from adam.commands.devices.devices import Devices
 from adam.repl_state import ReplState
-from adam.utils import log2
-from adam.apps import Apps
 
 class Cd(Command):
     COMMAND = 'cd'
@@ -31,101 +25,19 @@ class Cd(Command):
         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
+        with self.validate(args, state, apply=False) as (args, state):
+            if len(args) < 2:
+                return state
 
-        arg = args[1]
-        for dir in arg.split('/'):
-            if state.device == ReplState.P:
-                if dir == '':
-                    state.pg_path = None
-                else:
-                    context: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path, arg=dir)
-                    # patch up state.namespace from pg cd
-                    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_pod:
-                        state.app_pod = None
-                    elif state.app_app:
-                        state.app_app = None
-                    else:
-                        state.app_env = None
-                else:
-                    if state.app_app:
-                        state.app_pod = dir
-                    elif not state.app_env:
-                        tks = dir.split('@')
-                        if len(tks) > 1:
-                            state.namespace = tks[1]
+            device: Device = Devices.device(state)
+            arg = args[1]
+            for dir in arg.split('/'):
+                device.cd(dir, state)
 
-                        state.app_env = dir.split('@')[0]
-                    else:
-                        state.app_app = dir
-            elif state.device == ReplState.L:
-                pass
-            else:
-                if dir == '':
-                    state.sts = None
-                    state.pod = None
-                elif dir == '..':
-                    if state.pod:
-                        state.pod = None
-                    else:
-                        state.sts = None
-                else:
-                    if not state.sts:
-                        ss_and_ns = dir.split('@')
-                        state.sts = ss_and_ns[0]
-                        if len(ss_and_ns) > 1:
-                            state.namespace = ss_and_ns[1]
-                    elif not state.pod:
-                        p, _ = KubeContext.is_pod_name(dir)
-                        if p:
-                            state.pod = p
-                        else:
-                            names = CassandraClusters.pod_names_by_host_id(state.sts, state.namespace);
-                            if dir in names:
-                                state.pod = names[dir]
-                            else:
-                                log2('Not a valid pod name or host id.')
-
-        return state
+            return state
 
     def completion(self, state: ReplState):
-        if state.device == ReplState.P:
-            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.path())}}
-            else:
-                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} | {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:
-                return {Cd.COMMAND: {'..': None} | {env[0]: None for env in Apps.envs()}}
-        elif state.device == ReplState.C:
-            if state.pod:
-                return {Cd.COMMAND: {'..': None}}
-            elif state.sts:
-                return {Cd.COMMAND: {'..': None} | {p: None for p in StatefulSets.pod_names(state.sts, state.namespace)}}
-            else:
-                return {Cd.COMMAND: {p: None for p in StatefulSets.list_sts_names()}}
-
-        return {}
+        return Devices.device(state).cd_completion(Cd.COMMAND, state, default = {})
 
     def help(self, _: ReplState):
-        return f'{Cd.COMMAND} <path> | .. \t move around'
+        return f'{Cd.COMMAND} <path> | .. \t move around on the operational device hierarchy'

adam/commands/check.py

@@ -2,11 +2,13 @@ import click
 
 from adam.checks.check_result import CheckResult
 from adam.checks.check_utils import all_checks, checks_from_csv, run_checks
+from adam.commands import extract_options
 from adam.commands.command import Command
 from adam.commands.command_helpers import ClusterOrPodCommandHelper
 from adam.commands.issues import Issues
 from adam.repl_state import ReplState
 from adam.utils import lines_to_tabular, log
+from adam.utils_issues import IssuesUtils
 
 class Check(Issues):
     COMMAND = 'check'
@@ -30,36 +32,33 @@ class Check(Issues):
         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
+        with self.validate(args, state) as (args, state):
+            with extract_options(args, ['-s', '--show']) as (args, show_out):
+                if not args:
+                    if state.in_repl:
+                        log(lines_to_tabular([check.help() for check in all_checks()], separator=':'))
+                    else:
+                        log('* Check name is missing.')
+                        Command.display_help()
 
-        args, show = Command.extract_options(args, ['-s', '--show'])
+                    return 'arg missing'
 
-        if not args:
-            if state.in_repl:
-                log(lines_to_tabular([check.help() for check in all_checks()], separator=':'))
-            else:
-                log('* Check name is missing.')
-                Command.display_help()
-            return 'arg missing'
+                checks = checks_from_csv(args[0])
+                if not checks:
+                    return 'invalid check name'
 
-        checks = checks_from_csv(args[0])
-        if not checks:
-            return 'invalid check name'
+                results = run_checks(state.sts, state.namespace, state.pod, checks=checks, show_out=show_out)
 
-        results = run_checks(state.sts, state.namespace, state.pod, checks=checks, show_output=show)
+                issues = CheckResult.collect_issues(results)
+                IssuesUtils.show_issues(issues, in_repl=state.in_repl)
 
-        issues = CheckResult.collect_issues(results)
-        Issues.show_issues(issues, in_repl=state.in_repl)
-
-        return issues if issues else 'no issues found'
+                return issues if issues else 'no issues found'
 
     def completion(self, _: ReplState):
-        return {Check.COMMAND: {check.name(): None for check in all_checks()}}
+        return {Check.COMMAND: {check.name(): {'-s': None} for check in all_checks()}}
 
     def help(self, _: ReplState):
-        return f'{Check.COMMAND} <check-name>\t run a single check'
+        return f'{Check.COMMAND} <check-name> [-s]\t run a single check'
 
 class CheckCommandHelper(click.Command):
     def get_help(self, ctx: click.Context):

adam/commands/cli_commands.py

@@ -1,7 +1,7 @@
 import functools
 import re
 
-from adam.commands.reaper.reaper_session import ReaperSession
+from adam.commands.reaper.utils_reaper import Reapers
 from adam.config import Config
 from adam.utils_k8s.kube_context import KubeContext
 from adam.utils_k8s.secrets import Secrets
@@ -66,8 +66,7 @@ class CliCommands:
             return key.replace(f'{state.namespace}-', '').replace('-k8spg-cs-001', '')
         d |= {f'pg-{reduce_key(k)}': f'PGPASSWORD={v["postgres-admin-password"]} psql -h {v["postgres-db-endpoint"]} -p {v["postgres-db-port"]} -U {v["postgres-admin-username"]} postgres' for k, v in data.items()}
 
-        if r := ReaperSession.create(state):
-            reaper = r.reaper_spec(state)
+        if reaper := Reapers.reaper_spec(state):
             d |= {
                 'reaper-exec': reaper["exec"],
                 'reaper-forward': reaper["forward"],

adam/commands/code.py

@@ -2,7 +2,7 @@ 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.commands.cql.utils_cql 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
@@ -29,29 +29,26 @@ class Code(Command):
         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
+        with self.validate(args, state) as (args, 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=':'))
 
-        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
+            return state
 
     def completion(self, state: ReplState):
         return super().completion(state)