kaqing 2.0.184__py3-none-any.whl → 2.0.227__py3-none-any.whl

adam/sso/cred_cache.py

@@ -2,8 +2,7 @@ import os
 from pathlib import Path
 from dotenv import load_dotenv
 
-from adam.config import Config
-from adam.utils import debug, log_exc
+from adam.utils import creating_dir, debug, log_exc
 from adam.utils_k8s.kube_context import KubeContext
 
 class CredCache:
@@ -15,7 +14,7 @@ class CredCache:
 
     def __init__(self):
         if not hasattr(self, 'env_f'):
-            self.dir = f'{Path.home()}/.kaqing'
+            self.dir = creating_dir(f'{Path.home()}/.kaqing')
             self.env_f = f'{self.dir}/.credentials'
             # immutable - cannot reload with different file content
             load_dotenv(dotenv_path=self.env_f)
@@ -44,8 +43,6 @@ class CredCache:
             updated.append(f'IDP_PASSWORD={password}')
 
         if updated:
-            if not os.path.exists(self.env_f):
-                os.makedirs(self.dir, exist_ok=True)
             with open(self.env_f, 'w') as file:
                 file.write('\n'.join(updated))
 

adam/utils.py

@@ -1,11 +1,12 @@
+from abc import ABC
 from concurrent.futures import Future, ThreadPoolExecutor
 from contextlib import redirect_stdout
 import copy
 import csv
 from datetime import datetime
+import html
 import importlib
 import io
-import json
 import os
 from pathlib import Path
 import random
@@ -19,6 +20,8 @@ import sys
 import time
 import click
 import yaml
+from prompt_toolkit import print_formatted_text, HTML
+from prompt_toolkit.completion import Completer
 
 from . import __version__
 
@@ -26,10 +29,31 @@ T = TypeVar('T')
 
 log_state = threading.local()
 
-class LogConfig:
-    is_debug = lambda: False
-    is_debug_timing = lambda: False
-    is_display_help = True
+class Color:
+    gray = 'gray'
+
+class ConfigReadable:
+    def is_debug() -> bool:
+        pass
+
+    def get(self, key: str, default: T) -> T:
+        pass
+
+class ConfigHolder:
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(ConfigHolder, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self):
+        if not hasattr(self, 'config'):
+            # set by Config
+            self.config: 'ConfigReadable' = None
+            # only for testing
+            self.is_display_help = True
+            # set by ReplSession
+            self.append_command_history = lambda entry: None
 
 NO_SORT = 0
 SORT = 1
@@ -97,26 +121,42 @@ def convert_seconds(total_seconds_float):
 def epoch(timestamp_string: str):
     return parser.parse(timestamp_string).timestamp()
 
-def log(s = None):
+def log(s = None, text_color: str = None):
     if not loggable():
         return False
 
     # want to print empty line for False or empty collection
     if s == None:
         print()
+    elif text_color:
+        print_formatted_text(HTML(f'<ansi{text_color}>{html.escape(s)}</ansi{text_color}>'))
     else:
         click.echo(s)
 
     return True
 
-def log2(s = None, nl = True):
+def log2(s = None, nl = True, file: str = None, text_color: str = None):
     if not loggable():
         return False
 
     if s:
-        click.echo(s, err=True, nl=nl)
+        if file:
+            with open(file, 'at') as f:
+                f.write(s)
+                if nl:
+                    f.write('\n')
+        elif text_color:
+            print_formatted_text(HTML(f'<ansi{text_color}>{html.escape(s)}</ansi{text_color}>'))
+        else:
+            click.echo(s, err=True, nl=nl)
     else:
-        print(file=sys.stderr)
+        if file:
+            with open(file, 'at') as f:
+                f.write('\n')
+        elif text_color:
+            print_formatted_text(HTML(f'<ansi{text_color}>{html.escape(s)}</ansi{text_color}>'), file=sys.stderr)
+        else:
+            print(file=sys.stderr)
 
     return True
 
@@ -160,7 +200,11 @@ def deep_merge_dicts(dict1, dict2):
             merged_dict[key] = deep_merge_dicts(merged_dict[key], value)
         elif key not in merged_dict or value:
             # Otherwise, overwrite or add the value from dict2
-            merged_dict[key] = value
+            if key in merged_dict and isinstance(merged_dict[key], Completer):
+                pass
+                # print('SEAN completer found, ignoring', key, value)
+            else:
+                merged_dict[key] = value
     return merged_dict
 
 def deep_sort_dict(d):
@@ -198,7 +242,7 @@ def get_deep_keys(d, current_path=""):
     return keys
 
 def display_help(replace_arg = False):
-    if not LogConfig.is_display_help:
+    if not ConfigHolder().is_display_help:
         return
 
     args = copy.copy(sys.argv)
@@ -250,28 +294,10 @@ def json_to_csv(json_data: list[dict[any, any]], delimiter: str = ','):
     else:
         return None
 
-def log_to_file(config: dict[any, any]):
-    with log_exc():
-        base = f"/kaqing/logs"
-        os.makedirs(base, exist_ok=True)
-
-        now = datetime.now()
-        timestamp_str = now.strftime("%Y%m%d-%H%M%S")
-        filename = f"{base}/login.{timestamp_str}.txt"
-        with open(filename, 'w') as f:
-            if isinstance(config, dict):
-                try:
-                    json.dump(config, f, indent=4)
-                except:
-                    f.write(config)
-            else:
-                    f.write(config)
-
 def copy_config_file(rel_path: str, module: str, suffix: str = '.yaml', show_out = True):
-    dir = f'{Path.home()}/.kaqing'
+    dir = creating_dir(f'{Path.home()}/.kaqing')
     path = f'{dir}/{rel_path}'
     if not os.path.exists(path):
-        os.makedirs(dir, exist_ok=True)
         module = importlib.import_module(module)
         with open(path, 'w') as f:
             yaml.dump(module.config(), f, default_flow_style=False)
@@ -287,12 +313,15 @@ def is_lambda(func):
     return callable(func) and hasattr(func, '__name__') and func.__name__ == '<lambda>'
 
 def debug(s = None):
-    if LogConfig.is_debug():
-        log2(f'DEBUG {s}')
+    if ConfigHolder().config.is_debug():
+        log2(f'DEBUG {s}', text_color=Color.gray)
+
+def debug_complete(s = None):
+    CommandLog.log(f'DEBUG {s}', config=ConfigHolder().config.get('debugs.complete', 'off'))
 
 def debug_trace():
-    if LogConfig.is_debug():
-        log2(traceback.format_exc())
+    if ConfigHolder().config.is_debug():
+        log2(traceback.format_exc(), text_color=Color.gray)
 
 def in_docker() -> bool:
     if os.path.exists('/.dockerenv'):
@@ -309,34 +338,42 @@ def in_docker() -> bool:
     return False
 
 class Ing:
-    def __init__(self, msg: str, suppress_log=False):
+    def __init__(self, msg: str, suppress_log=False, job_log: str = None, condition = True):
         self.msg = msg
         self.suppress_log = suppress_log
+        self.job_log = job_log
+        self.condition = condition
 
     def __enter__(self):
+        if not self.condition:
+            return None
+
         if not hasattr(log_state, 'ing_cnt'):
             log_state.ing_cnt = 0
 
         try:
             if not log_state.ing_cnt:
-                if not self.suppress_log and not LogConfig.is_debug():
-                    log2(f'{self.msg}...', nl=False)
+                if not self.suppress_log and not ConfigHolder().config.is_debug():
+                    log2(f'{self.msg}...', nl=False, file=self.job_log)
 
             return None
         finally:
             log_state.ing_cnt += 1
 
     def __exit__(self, exc_type, exc_val, exc_tb):
+        if not self.condition:
+            return False
+
         log_state.ing_cnt -= 1
         if not log_state.ing_cnt:
-            if not self.suppress_log and not LogConfig.is_debug():
-                log2(' OK')
+            if not self.suppress_log and not ConfigHolder().config.is_debug():
+                log2(' OK', file=self.job_log)
 
         return False
 
-def ing(msg: str, body: Callable[[], None]=None, suppress_log=False):
+def ing(msg: str, body: Callable[[], None]=None, suppress_log=False, job_log: str = None, condition = True):
     if not body:
-        return Ing(msg, suppress_log=suppress_log)
+        return Ing(msg, suppress_log=suppress_log, job_log=job_log, condition=condition)
 
     r = None
 
@@ -350,7 +387,7 @@ def ing(msg: str, body: Callable[[], None]=None, suppress_log=False):
     return r
 
 def loggable():
-    return LogConfig.is_debug() or not hasattr(log_state, 'ing_cnt') or not log_state.ing_cnt
+    return ConfigHolder().config and ConfigHolder().config.is_debug() or not hasattr(log_state, 'ing_cnt') or not log_state.ing_cnt
 
 class TimingNode:
     def __init__(self, depth: int, s0: time.time = time.time(), line: str = None):
@@ -378,7 +415,7 @@ class LogTiming:
         self.s0 = s0
 
     def __enter__(self):
-        if not LogConfig.is_debug_timing():
+        if (config := ConfigHolder().config.get('debugs.timings', 'off')) not in ['on', 'file']:
             return
 
         if not hasattr(log_state, 'timings'):
@@ -390,7 +427,7 @@ class LogTiming:
             self.s0 = time.time()
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        if not LogConfig.is_debug_timing():
+        if (config := ConfigHolder().config.get('debugs.timings', 'off')) not in ['on', 'file']:
             return False
 
         child = log_state.timings
@@ -401,7 +438,9 @@ class LogTiming:
         log_state.timings = self.me
 
         if not self.me.depth:
-            log2(self.me.tree())
+            # log timings finally
+            CommandLog.log(self.me.tree(), config)
+
             log_state.timings = TimingNode(0)
 
         return False
@@ -410,7 +449,7 @@ def log_timing(msg: str, body: Callable[[], None]=None, s0: time.time = None):
     if not s0 and not body:
         return LogTiming(msg, s0=s0)
 
-    if not LogConfig.is_debug_timing():
+    if not ConfigHolder().config.get('debugs.timings', False):
         if body:
             return body()
 
@@ -430,7 +469,9 @@ def log_timing(msg: str, body: Callable[[], None]=None, s0: time.time = None):
 
 def timing_log_line(depth: int, msg: str, s0: time.time):
     elapsed = time.time() - s0
-    prefix = '[timings] '
+    offloaded = '-' if threading.current_thread().name.startswith('offload') or threading.current_thread().name.startswith('async') else '+'
+    prefix = f'[{offloaded} timings] '
+
     if depth:
         if elapsed > 0.01:
             prefix = ('  ' * (depth-1)) + '* '
@@ -526,7 +567,7 @@ class LogTrace:
             elif self.err_msg is not False and self.err_msg:
                 log2(self.err_msg)
 
-            if self.err_msg is not False and LogConfig.is_debug():
+            if self.err_msg is not False and ConfigHolder().config.is_debug():
                 traceback.print_exception(exc_type, exc_val, exc_tb, file=sys.stderr)
 
         # swallow exception
@@ -567,37 +608,44 @@ class ParallelService:
         else:
             return iterator
 
+thread_pools: dict[str, ThreadPoolExecutor] = {}
+thread_pool_lock = threading.Lock()
+
 class ParallelMapHandler:
-    def __init__(self, collection: list, workers: int, samples: int = sys.maxsize, msg: str = None, collect = True):
+    def __init__(self, collection: list, workers: int, samples: int = sys.maxsize, msg: str = None, collect = True, name = None):
         self.collection = collection
         self.workers = workers
         self.executor = None
         self.samples = samples
         self.msg = msg
         if msg and msg.startswith('d`'):
-            if LogConfig.is_debug():
+            if ConfigHolder().config.is_debug():
                 self.msg = msg.replace('d`', '', 1)
             else:
                 self.msg = None
         self.collect = collect
+        self.name = name
 
         self.begin = []
         self.end = []
         self.start_time = None
 
     def __enter__(self):
+        self.start_time = None
+
         self.calc_msgs()
 
         if self.workers > 1 and (not self.size() or self.size()) and self.samples == sys.maxsize:
             self.start_time = time.time()
 
-            self.executor = ThreadPoolExecutor(max_workers=self.workers)
+            self.executor = self.pool()
+            # self.executor = ThreadPoolExecutor(max_workers=self.workers)
             self.executor.__enter__()
 
         return ParallelService(self)
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        if self.executor:
+        if not self.name and self.executor:
             self.executor.__exit__(exc_type, exc_val, exc_tb)
 
         if self.end:
@@ -605,6 +653,15 @@ class ParallelMapHandler:
 
         return False
 
+    def pool(self, thread_name_prefix: str = None):
+        if not self.name:
+            return ThreadPoolExecutor(max_workers=self.workers)
+
+        if self.name not in thread_pools:
+            thread_pools[self.name] = ThreadPoolExecutor(max_workers=self.workers, thread_name_prefix=thread_name_prefix)
+
+        return thread_pools[self.name]
+
     def size(self):
         if not self.collection:
             return 0
@@ -615,25 +672,28 @@ class ParallelMapHandler:
         if not self.msg:
             return
 
+        self.begin = []
+        self.end = []
         size = self.size()
         offloaded = False
         serially = False
         sampling = False
         if size == 0:
             offloaded = True
-            self.msg = self.msg.replace('{size}', '1')
+            msg = self.msg.replace('{size}', '1')
         elif self.workers > 1 and size > 1 and self.samples == sys.maxsize:
-            self.msg = self.msg.replace('{size}', f'{size}')
+            msg = self.msg.replace('{size}', f'{size}')
         elif self.samples < sys.maxsize:
             sampling = True
+            samples = self.samples
             if self.samples > size:
-                self.samples = size
-            self.msg = self.msg.replace('{size}', f'{self.samples}/{size} sample')
+                samples = size
+            msg = self.msg.replace('{size}', f'{samples}/{size} sample')
         else:
             serially = True
-            self.msg = self.msg.replace('{size}', f'{size}')
+            msg = self.msg.replace('{size}', f'{size}')
 
-        for token in self.msg.split(' '):
+        for token in msg.split(' '):
             if '|' in token:
                 self.begin.append(token.split('|')[0])
                 if not sampling and not serially and not offloaded:
@@ -650,8 +710,19 @@ class ParallelMapHandler:
         else:
             log2(f'{" ".join(self.begin)} with {self.workers} workers...')
 
-def parallelize(collection: list, workers: int = 0, samples = sys.maxsize, msg: str = None, collect = True):
-    return ParallelMapHandler(collection, workers, samples = samples, msg = msg, collect = collect)
+# parallelizers: dict[str, ParallelMapHandler] = {}
+# parallelizer_lock = threading.Lock()
+
+def parallelize(collection: list, workers: int = 0, samples = sys.maxsize, msg: str = None, collect = True, name = None):
+    return ParallelMapHandler(collection, workers, samples = samples, msg = msg, collect = collect, name = name)
+    # if not name:
+    #     return ParallelMapHandler(collection, workers, samples = samples, msg = msg, collect = collect)
+
+    # with parallelizer_lock:
+    #     if name not in parallelizers:
+    #         parallelizers[name] = ParallelMapHandler(collection, workers, samples = samples, msg = msg, collect = collect, name = name)
+
+    # return parallelizers[name]
 
 class OffloadService:
     def __init__(self, handler: 'OffloadHandler'):
@@ -670,22 +741,24 @@ class OffloadService:
             return future
 
 class OffloadHandler(ParallelMapHandler):
-    def __init__(self, max_workers: int, msg: str = None):
-        super().__init__(None, max_workers, msg=msg, collect=False )
+    def __init__(self, max_workers: int, msg: str = None, name: str = None):
+        super().__init__(None, max_workers, msg=msg, collect=False, name=f'offload-{name}')
 
     def __enter__(self):
+        self.start_time = None
         self.calc_msgs()
 
-        if self.workers > 1 and (not self.size() or self.size()) and self.samples == sys.maxsize:
+        if self.workers > 1:
             self.start_time = time.time()
 
-            self.executor = ThreadPoolExecutor(max_workers=self.workers)
+            self.executor = self.pool(thread_name_prefix='offload')
+            # self.executor = ThreadPoolExecutor(max_workers=self.workers, thread_name_prefix='offload')
             self.executor.__enter__()
 
         return OffloadService(self)
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        if self.executor:
+        if not self.name and self.executor:
             self.executor.__exit__(exc_type, exc_val, exc_tb)
 
         if self.end:
@@ -693,38 +766,33 @@ class OffloadHandler(ParallelMapHandler):
 
         return False
 
-    def size(self):
-        if not self.collection:
-            return 0
-
-        return len(self.collection)
-
     def calc_msgs(self):
         if not self.msg:
             return
 
+        self.begin = []
+        self.end = []
         size = self.size()
-            # return
 
         offloaded = False
         serially = False
         sampling = False
         if size == 0:
             offloaded = True
-            self.msg = self.msg.replace('{size}', '1')
+            msg = self.msg.replace('{size}', '1')
         elif self.workers > 1 and size > 1 and self.samples == sys.maxsize:
-            self.msg = self.msg.replace('{size}', f'{size}')
+            msg = self.msg.replace('{size}', f'{size}')
         elif self.samples < sys.maxsize:
             sampling = True
-            if self.samples > size:
-                self.samples = size
-            self.msg = self.msg.replace('{size}', f'{self.samples}/{size} sample')
+            samples = self.samples
+            if samples > size:
+                samples = size
+            msg = self.msg.replace('{size}', f'{samples}/{size} sample')
         else:
             serially = True
-            self.msg = self.msg.replace('{size}', f'{size}')
-            # return
+            msg = self.msg.replace('{size}', f'{size}')
 
-        for token in self.msg.split(' '):
+        for token in msg.split(' '):
             if '|' in token:
                 self.begin.append(token.split('|')[0])
                 if not sampling and not serially and not offloaded:
@@ -741,5 +809,114 @@ class OffloadHandler(ParallelMapHandler):
         else:
             log2(f'{" ".join(self.begin)} with {self.workers} workers...')
 
-def offload(max_workers: int = 3, msg: str = None):
-    return OffloadHandler(max_workers, msg = msg)
+def offload(max_workers: int = 3, msg: str = None, name: str = None):
+    return OffloadHandler(max_workers, msg = msg, name = name)
+
+def kaqing_log_file_name(suffix = 'log'):
+    return f"{log_dir()}/{datetime.now().strftime('%d%H%M%S')}.{suffix}"
+
+def log_dir():
+    return creating_dir(ConfigHolder().config.get('log-dir', '/tmp/qing-db/q/logs'))
+
+def log_to_pods():
+    return ConfigHolder().config.get('job.log-to-pods', True)
+
+def pod_log_dir():
+    return ConfigHolder().config.get('pod-log-dir', '/tmp/q/logs')
+
+class LogFileHandler:
+    def __init__(self, suffix = 'log', condition=True):
+        self.suffix = suffix
+        self.condition = condition
+
+    def __enter__(self):
+        self.f = None
+        if self.condition:
+            self.f = open(kaqing_log_file_name(suffix=self.suffix), 'w')
+            self.f.__enter__()
+
+        return self.f
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.f:
+            self.f.__exit__(exc_type, exc_val, exc_tb)
+
+            if ConfigHolder().append_command_history:
+                ConfigHolder().append_command_history(f':cat {self.f.name}')
+
+        return False
+
+def kaqing_log_file(suffix = 'log', condition=True):
+    return LogFileHandler(suffix = suffix, condition=condition)
+
+class CommandLog:
+    log_file = None
+
+    def log(line: str, config: str = 'off'):
+        if config == 'file':
+            if not CommandLog.log_file:
+                try:
+                    CommandLog.log_file = open(kaqing_log_file_name(suffix='cmd.log'), 'w')
+                except:
+                    pass
+
+            try:
+                CommandLog.log_file.write(line + '\n')
+            except:
+                pass
+        elif config == 'on':
+            log2(line, text_color=Color.gray)
+
+    def close_log_file():
+        if CommandLog.log_file:
+            try:
+                CommandLog.log_file.close()
+            except:
+                pass
+
+            if ConfigHolder().append_command_history:
+                ConfigHolder().append_command_history(f':cat {CommandLog.log_file.name}')
+
+            CommandLog.log_file = None
+
+class ExecResult(ABC):
+    def exit_code(self) -> int:
+        pass
+
+    def cat_log_file_cmd(self) -> str:
+        pass
+
+_dirs_created = set()
+
+def creating_dir(dir):
+    if dir not in _dirs_created:
+        _dirs_created.add(dir)
+        if not os.path.exists(dir):
+            os.makedirs(dir, exist_ok=True)
+
+    return dir
+
+class LogFile(str):
+    def __init__(self, s: str):
+        super().__init__()
+
+    def __repr__(self):
+        return super().__repr__()
+
+    def to_command(self, cmd: str = ':tail'):
+        return f'{cmd} {self}'
+
+class PodLogFile(LogFile):
+    def __new__(cls, value, pod: str, size: str = None):
+        return super().__new__(cls, value)
+
+    def __init__(self, value, pod: str, size: str = None):
+         super().__init__(value)
+         self.pod = pod
+         self.size = size
+
+    def __repr__(self):
+        return super().__repr__()
+
+    def to_command(self, cmd: str = 'tail'):
+        return f'@{self.pod} {cmd} {self}'