kaqing 2.0.30__tar.gz → 2.0.31__tar.gz

{kaqing-2.0.30 → kaqing-2.0.31}/PKG-INFO

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

{kaqing-2.0.30 → kaqing-2.0.31}/adam/commands/alter_tables.py

@@ -1,12 +1,9 @@
-import click
-
 from adam.commands.command import Command
-from adam.commands.command_helpers import ClusterOrPodCommandHelper
-from adam.commands.cql_utils import parse_cql_desc_tables, run_cql
+from adam.commands.cql_utils import tables as get_tables, run_cql
 from adam.config import Config
 from adam.pod_exec_result import PodExecResult
 from adam.repl_state import ReplState, RequiredState
-from adam.utils import log, log2
+from adam.utils import log2
 
 class AlterTables(Command):
     COMMAND = 'alter tables with'
@@ -47,16 +44,16 @@ class AlterTables(Command):
         args, include_reaper = Command.extract_options(args, '--include-reaper')
         arg_str = ' '.join(args)
 
-        r: list[PodExecResult] = run_cql(state, 'describe tables', show_out=False, on_any=True)
-        if not r:
-            log2('No pod is available')
-            return 'no-pod'
+        # r: list[PodExecResult] = run_cql(state, 'describe tables', show_out=False, on_any=True)
+        # if not r:
+        #     log2('No pod is available')
+        #     return 'no-pod'
 
         excludes = [e.strip(' \r\n') for e in Config().get(
             'cql.alter-tables.excludes',
             'system_auth,system_traces,reaper_db,system_distributed,system_views,system,system_schema,system_virtual_schema').split(',')]
         batching = Config().get('cql.alter-tables.batching', True)
-        tables = parse_cql_desc_tables(r[0].stdout)
+        tables = get_tables(state, on_any=True)
         for k, v in tables.items():
             if k not in excludes or k == 'reaper_db' and include_reaper:
                 if batching:

{kaqing-2.0.30 → kaqing-2.0.31}/adam/commands/cql_utils.py

@@ -1,6 +1,7 @@
 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
@@ -10,6 +11,8 @@ from adam.utils import log2
 
 @functools.lru_cache()
 def keyspaces(sts: str, namespace: str):
+    Config().wait_log("Inspecting Cassandra Keyspaces...")
+
     user, pw = Secrets.get_user_pass(sts, namespace, secret_path='cql.secret')
     command = f'cqlsh -u {user} -p {pw} -e "describe keyspaces"'
 
@@ -20,6 +23,18 @@ def keyspaces(sts: str, namespace: str):
 
     return parse_cql_desc_keyspaces(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]
+
+@functools.lru_cache()
+def tables(state: ReplState, on_any=False):
+    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 parse_cql_desc_tables(r[0].stdout)
+
 def run_cql(state: ReplState, cql: str, opts: list = [], show_out = False, use_single_quotes = False, on_any = False):
     user, pw = Secrets.get_user_pass(state.sts if state.sts else state.pod, state.namespace, secret_path='cql.secret')
     if use_single_quotes:

{kaqing-2.0.30 → kaqing-2.0.31}/adam/commands/cqlsh.py

@@ -2,7 +2,7 @@ import click
 
 from adam.commands.command import Command
 from adam.commands.command_helpers import ClusterOrPodCommandHelper
-from adam.commands.cql_utils import run_cql
+from adam.commands.cql_utils import run_cql, table_names, tables
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log, log2
 
@@ -54,12 +54,13 @@ class Cqlsh(Command):
 
     def completion(self, state: ReplState) -> dict[str, any]:
         if state.sts or state.pod:
+            ts = table_names(state)
             return {Cqlsh.COMMAND: None} | {
-                'delete': {'from': None},
-                'insert': {'into': None},
-                'select': None,
-                'update': None,
-                'describe': {'keyspaces': None},
+                'delete': {'from': {t: {'where': None} for t in ts}},
+                'insert': {'into': {t: {'values': None} for t in ts}},
+                'select': {'*': {'from': {t: {'limit': {'1': None}, 'where': None} for t in ts}}},
+                'update': {t: {'set': None} for t in ts},
+                'describe': {'keyspaces': None, 'table': {t: None for t in ts}, 'tables': None},
             }
 
         return {}

{kaqing-2.0.30/adam/commands → kaqing-2.0.31/adam/commands/describe}/describe_keyspace.py

@@ -1,12 +1,8 @@
-import click
-
 from adam.commands.command import Command
-from adam.commands.command_helpers import ClusterOrPodCommandHelper
-from adam.commands.cql_utils import keyspaces, parse_cql_desc_tables, run_cql
-from adam.config import Config
+from adam.commands.cql_utils import keyspaces, run_cql
 from adam.pod_exec_result import PodExecResult
 from adam.repl_state import ReplState, RequiredState
-from adam.utils import log, log2
+from adam.utils import log2
 
 class DescribeKeyspace(Command):
     COMMAND = 'describe keyspace'
@@ -34,6 +30,8 @@ class DescribeKeyspace(Command):
         if not self.validate_state(state):
             return state
 
+        args, all_nodes = Command.extract_options(args, '--all-nodes')
+
         if not args:
             if state.in_repl:
                 log2('Please enter keyspace name')
@@ -44,7 +42,7 @@ class DescribeKeyspace(Command):
 
             return 'missing-keyspace'
 
-        r: list[PodExecResult] = run_cql(state, f'describe keyspace {args[0]}', show_out=True, on_any=True)
+        r: list[PodExecResult] = run_cql(state, f'describe keyspace {args[0]}', show_out=True, on_any=not all_nodes)
         if not r:
             log2('No pod is available')
             return 'no-pod'
@@ -54,10 +52,9 @@ class DescribeKeyspace(Command):
 
     def completion(self, state: ReplState) -> dict[str, any]:
         if state.sts:
-            state.wait_log("Inspecting Cassandra Keyspaces...")
-            return super().completion(state, {ks: None for ks in keyspaces(state.sts, state.namespace)})
+            return super().completion(state, {ks: {'--all-nodes': None} for ks in keyspaces(state.sts, state.namespace)})
 
         return {}
 
     def help(self, _: ReplState) -> str:
-        return f'{DescribeKeyspace.COMMAND} <keyspace-name>\t describe Cassandra keyspace'
+        return f'{DescribeKeyspace.COMMAND} <keyspace-name> [--all-nodes]\t describe Cassandra keyspace'

kaqing-2.0.31/adam/commands/describe/describe_keyspaces.py

@@ -0,0 +1,50 @@
+from adam.commands.command import Command
+from adam.commands.cql_utils import keyspaces, run_cql
+from adam.pod_exec_result import PodExecResult
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log2
+
+class DescribeKeyspaces(Command):
+    COMMAND = 'describe keyspaces'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(DescribeKeyspaces, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def required(self):
+        return RequiredState.CLUSTER
+
+    def command(self):
+        return DescribeKeyspaces.COMMAND
+
+    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
+
+        _, all_nodes = Command.extract_options(args, '--all-nodes')
+
+        r: list[PodExecResult] = run_cql(state, f'describe keyspaces', show_out=True, on_any=not all_nodes)
+        if not r:
+            log2('No pod is available')
+            return 'no-pod'
+
+        # do not continue to cql route
+        return state
+
+    def completion(self, state: ReplState) -> dict[str, any]:
+        if state.sts:
+            return super().completion(state, {'--all-nodes': None})
+
+        return {}
+
+    def help(self, _: ReplState) -> str:
+        return f'{DescribeKeyspaces.COMMAND} [--all-nodes]\t describe Cassandra keyspaces'

kaqing-2.0.31/adam/commands/describe/describe_table.py

@@ -0,0 +1,60 @@
+from adam.commands.command import Command
+from adam.commands.cql_utils import keyspaces, run_cql, table_names, tables
+from adam.pod_exec_result import PodExecResult
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log2
+
+class DescribeTable(Command):
+    COMMAND = 'describe table'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(DescribeTable, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def required(self):
+        return RequiredState.CLUSTER
+
+    def command(self):
+        return DescribeTable.COMMAND
+
+    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, all_nodes = Command.extract_options(args, '--all-nodes')
+
+        if not args:
+            if state.in_repl:
+                log2('Please enter table name')
+            else:
+                log2('* table name is missing.')
+                log2()
+                Command.display_help()
+
+            return 'missing-table'
+
+        r: list[PodExecResult] = run_cql(state, f'describe table {args[0]}', show_out=True, on_any=not all_nodes)
+        if not r:
+            log2('No pod is available')
+            return 'no-pod'
+
+        # do not continue to cql route
+        return state
+
+    def completion(self, state: ReplState) -> dict[str, any]:
+        if state.sts:
+            return super().completion(state, {t: {'--all-nodes': None} for t in table_names(state)})
+
+        return {}
+
+    def help(self, _: ReplState) -> str:
+        return f'{DescribeTable.COMMAND} <table-name> [--all-nodes]\t describe Cassandra table'

kaqing-2.0.31/adam/commands/describe/describe_tables.py

@@ -0,0 +1,50 @@
+from adam.commands.command import Command
+from adam.commands.cql_utils import keyspaces, run_cql, table_names, tables
+from adam.pod_exec_result import PodExecResult
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log2
+
+class DescribeTables(Command):
+    COMMAND = 'describe tables'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(DescribeTables, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def required(self):
+        return RequiredState.CLUSTER
+
+    def command(self):
+        return DescribeTables.COMMAND
+
+    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
+
+        _, all_nodes = Command.extract_options(args, '--all-nodes')
+
+        r: list[PodExecResult] = run_cql(state, f'describe tables', show_out=True, on_any=not all_nodes)
+        if not r:
+            log2('No pod is available')
+            return 'no-pod'
+
+        # do not continue to cql route
+        return state
+
+    def completion(self, state: ReplState) -> dict[str, any]:
+        if state.sts:
+            return super().completion(state, {'--all-nodes': None})
+
+        return {}
+
+    def help(self, _: ReplState) -> str:
+        return f'{DescribeTables.COMMAND} [--all-nodes]\t describe Cassandra tables'

{kaqing-2.0.30 → kaqing-2.0.31}/adam/commands/preview_table.py

@@ -1,7 +1,7 @@
 import functools
 
 from adam.commands.command import Command
-from adam.commands.cql_utils import parse_cql_desc_tables, run_cql
+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
@@ -74,10 +74,9 @@ class PreviewTable(Command):
         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()}}
-        else:
-            if state.pod:
-                tables = PreviewTable.cql_tables(state)
-                return {PreviewTable.COMMAND: {f'{k}.{t}': None for k, ts in tables.items() for t in ts}}
+        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}}
 
         return {}
 
@@ -86,8 +85,16 @@ class PreviewTable(Command):
 
     @functools.lru_cache()
     def cql_tables(state: ReplState):
-        r: PodExecResult =  run_cql(state, 'describe tables', show_out=False)
-        return parse_cql_desc_tables(r.stdout)
+        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):

{kaqing-2.0.30 → kaqing-2.0.31}/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):
-            state.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.30 → kaqing-2.0.31}/adam/config.py

@@ -17,6 +17,7 @@ class Config:
 
     def __init__(self, path: str = None, is_user_entry = False):
         if path:
+            self.wait_log_flag = False
             try:
                 with open(path) as f:
                     self.params = cast(dict[str, any], yaml.safe_load(f))
@@ -83,4 +84,12 @@ class Config:
             log2(f'incorrect path: {key}')
             return None
 
-        return v if v else 'false'
+        return v if v else 'false'
+
+    def wait_log(self, msg: str):
+        if not self.wait_log_flag:
+            log2(msg)
+            self.wait_log_flag = True
+
+    def clear_wait_log_flag(self):
+        self.wait_log_flag = False

{kaqing-2.0.30 → kaqing-2.0.31}/adam/k8s_utils/cassandra_clusters.py

@@ -3,6 +3,7 @@ from concurrent.futures import ThreadPoolExecutor
 import sys
 from typing import TypeVar
 
+from adam.config import Config
 from adam.k8s_utils.cassandra_nodes import CassandraNodes
 from adam.pod_exec_result import PodExecResult
 from adam.utils import log2

{kaqing-2.0.30 → kaqing-2.0.31}/adam/k8s_utils/pods.py

@@ -47,7 +47,7 @@ class Pods:
 
         if not max_workers:
             max_workers = Config().action_workers(action, 0)
-        if not on_any and  max_workers > 0:
+        if not on_any and max_workers > 0:
             # if parallel, node sampling is suppressed
             if KubeContext.show_parallelism():
                 log2(f'Executing on all nodes from statefulset in parallel...')
@@ -79,7 +79,8 @@ class Pods:
                 log2(f'Executing on {adj} nodes from statefulset...')
             for pod_name in pods:
                 try:
-                    result = body(None, pod_name, namespace, show_out)
+                    # disable stdout from the pod_exec, then show the output in a for loop
+                    result = body(None, pod_name, namespace, False)
                     if post:
                         result = post(result, show_out=show_out)
                     results.append(result)

{kaqing-2.0.30 → kaqing-2.0.31}/adam/repl.py

@@ -70,7 +70,7 @@ def enter_repl(state: ReplState):
             cluster = ss[0]
             state.sts = cluster[0]
             state.namespace = cluster[1]
-            state.wait_log(f'Moving to the only Cassandra cluster: {state.sts}@{state.namespace}...')
+            Config().wait_log(f'Moving to the only Cassandra cluster: {state.sts}@{state.namespace}...')
     elif state.device == ReplState.A:
         if app := Config().get('repl.auto-enter-app', 'c3/c3'):
             if app != 'no':
@@ -78,9 +78,9 @@ def enter_repl(state: ReplState):
                 state.app_env = ea[0]
                 if len(ea) > 1:
                     state.app_app = ea[1]
-                    state.wait_log(f'Moving to {state.app_env}/{state.app_app}...')
+                    Config().wait_log(f'Moving to {state.app_env}/{state.app_app}...')
                 else:
-                    state.wait_log(f'Moving to {state.app_env}...')
+                    Config().wait_log(f'Moving to {state.app_env}...')
 
     kb = KeyBindings()
 
@@ -151,7 +151,7 @@ def enter_repl(state: ReplState):
                 log2(e)
                 Config().debug(traceback.format_exc())
         finally:
-            state.clear_wait_log_flag()
+            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}')
 
@@ -168,5 +168,5 @@ def repl(kubeconfig: str, config: str, param: list[str], cluster:str, namespace:
         return
 
     state = ReplState(device=Config().get('repl.start-drive', 'a'), ns_sts=cluster, namespace=namespace, in_repl=True)
-    state, _ = state.apply_args(extra_args)
+    state, _ = state.apply_device_arg(extra_args)
     enter_repl(state)

{kaqing-2.0.30 → kaqing-2.0.31}/adam/repl_commands.py

@@ -11,7 +11,10 @@ from adam.commands.deploy.undeploy import Undeploy
 from adam.commands.deploy.undeploy_frontend import UndeployFrontend
 from adam.commands.deploy.undeploy_pg_agent import UndeployPgAgent
 from adam.commands.deploy.undeploy_pod import UndeployPod
-from adam.commands.describe_keyspace import DescribeKeyspace
+from adam.commands.describe.describe_keyspace import DescribeKeyspace
+from adam.commands.describe.describe_keyspaces import DescribeKeyspaces
+from adam.commands.describe.describe_table import DescribeTable
+from adam.commands.describe.describe_tables import DescribeTables
 from adam.commands.shell import Shell
 from adam.commands.show.show_app_queues import ShowAppQueues
 from adam.commands.cp import ClipboardCopy
@@ -76,14 +79,15 @@ class ReplCommands:
                 GetParam(), SetParam(), ShowParams(), ShowKubectlCommands(), ShowLogin(), ShowAdam()]
 
     def cassandra_check() -> list[Command]:
-        return [DescribeKeyspace(), ShowCassandraStatus(), ShowCassandraVersion(), ShowRepairs(), ShowStorage(), ShowProcesses(), Check(), Issues(), NodeTool(), Report()]
+        return [DescribeKeyspace(), DescribeKeyspaces(), DescribeTable(), DescribeTables(), ShowCassandraStatus(),
+                ShowCassandraVersion(), ShowRepairs(), ShowStorage(), ShowProcesses(), Check(), Issues(), NodeTool(), Report()]
 
     def cassandra_ops() -> list[Command]:
-        # return Medusa.cmd_list() + [Restart(), RollOut(), Watch()] + Reaper.cmd_list() + Repair.cmd_list()
         return [AlterTables()] + Medusa.cmd_list() + [Restart(), RollOut(), Watch()] + Reaper.cmd_list() + Repair.cmd_list()
 
     def tools() -> list[Command]:
-        return [Cqlsh(), Postgres(), Bash(), Shell(), CodeStart(), CodeStop(), DeployFrontend(), UndeployFrontend(), DeployPod(), UndeployPod(), DeployPgAgent(), UndeployPgAgent()]
+        return [Cqlsh(), Postgres(), Bash(), Shell(), CodeStart(), CodeStop(), DeployFrontend(), UndeployFrontend(),
+                DeployPod(), UndeployPod(), DeployPgAgent(), UndeployPgAgent()]
 
     def app() -> list[Command]:
         return [ShowAppActions(), ShowAppId(), ShowAppQueues(), AppPing(), App()]

{kaqing-2.0.30 → kaqing-2.0.31}/adam/repl_state.py

@@ -67,7 +67,7 @@ class ReplState:
         self.in_repl = in_repl
         self.bash_session = bash_session
         self.remote_dir = remote_dir
-        self.wait_log_flag = False
+        # self.wait_log_flag = False
 
         if ns_sts:
             nn = ns_sts.split('@')
@@ -120,6 +120,26 @@ class ReplState:
 
         return (state, new_args)
 
+    def apply_device_arg(self, args: list[str], cmd: list[str] = None) -> tuple['ReplState', list[str]]:
+        state = self
+
+        new_args = []
+        for index, arg in enumerate(args):
+            if index < 6:
+                state = copy.copy(state)
+
+                if arg in [f'{ReplState.A}:', f'{ReplState.C}:', f'{ReplState.P}:']:
+                    state.device = arg.strip(':')
+                else:
+                    new_args.append(arg)
+            else:
+                new_args.append(arg)
+
+        if cmd:
+            new_args = new_args[len(cmd):]
+
+        return (state, new_args)
+
     def validate(self, required: RequiredState = None, pg_required: RequiredState = None, app_required: RequiredState = None):
         if not pg_required and not app_required:
             if required == RequiredState.CLUSTER:
@@ -200,12 +220,4 @@ class ReplState:
         if self.bash_session and self.bash_session.device:
             self.device = self.bash_session.device
 
-        self.bash_session = None
-
-    def wait_log(self, msg: str):
-        if not self.wait_log_flag:
-            log2(msg)
-            self.wait_log_flag = True
-
-    def clear_wait_log_flag(self):
-        self.wait_log_flag = False
+        self.bash_session = None

kaqing-2.0.31/adam/version.py

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

{kaqing-2.0.30 → kaqing-2.0.31}/kaqing.egg-info/PKG-INFO

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

{kaqing-2.0.30 → kaqing-2.0.31}/kaqing.egg-info/SOURCES.txt

@@ -62,7 +62,6 @@ adam/commands/commands_utils.py
 adam/commands/cp.py
 adam/commands/cql_utils.py
 adam/commands/cqlsh.py
-adam/commands/describe_keyspace.py
 adam/commands/devices.py
 adam/commands/exit.py
 adam/commands/help.py
@@ -94,6 +93,11 @@ adam/commands/deploy/undeploy.py
 adam/commands/deploy/undeploy_frontend.py
 adam/commands/deploy/undeploy_pg_agent.py
 adam/commands/deploy/undeploy_pod.py
+adam/commands/describe/__init__.py
+adam/commands/describe/describe_keyspace.py
+adam/commands/describe/describe_keyspaces.py
+adam/commands/describe/describe_table.py
+adam/commands/describe/describe_tables.py
 adam/commands/medusa/__init__.py
 adam/commands/medusa/medusa.py
 adam/commands/medusa/medusa_backup.py

{kaqing-2.0.30 → kaqing-2.0.31}/setup.py

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

kaqing-2.0.30/adam/version.py

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