hcs-core 0.1.250__py3-none-any.whl → 0.1.316__py3-none-any.whl

hcs_core/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.316"

hcs_core/ctxp/__init__.py

@@ -13,7 +13,15 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-from ._init import init
-from .util import panic, error, CtxpException, launch_text_editor, choose
-from . import profile, config, var_template, state
-from .profile_store import profile_store
+from . import config as config
+from . import profile as profile
+from . import state as state
+from . import var_template as var_template
+from ._init import init as init
+from ._init import init_cli as init_cli
+from .profile_store import profile_store as profile_store
+from .util import CtxpException as CtxpException
+from .util import choose as choose
+from .util import error as error
+from .util import launch_text_editor as launch_text_editor
+from .util import panic as panic

hcs_core/ctxp/_init.py

@@ -13,27 +13,99 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-import click
+import os
 from os import path
 from pathlib import Path
-from . import profile
-from . import state
-from . import config
-from . import cli_processor
-
-user_home = str(Path.home())
-
-
-def init(
-    cli_name: str,
-    main_cli: click.Group,
-    commands_dir: str = "./cmds",
-    store_path: str = user_home,
-    config_path="./config",
-):
-    real_store_path = path.join(store_path, "." + cli_name)
-    state.init(real_store_path, ".state")
-    profile.init(real_store_path)
-    config.init(config_path)
-
-    return cli_processor.init(main_cli, commands_dir)
+
+import click
+
+from . import cli_processor, config, profile, state, telemetry
+
+
+def _get_store_path():
+    if os.name == "nt":  # Windows OS
+        return str(Path.home())
+    uid = os.getuid()
+    if uid == 0 or uid == 1000:
+        return "/tmp"
+    if os.path.exists("/.dockerenv"):
+        return "/tmp"
+    return str(Path.home())
+
+
+user_home = _get_store_path()
+
+
+_initialized_app_name = None
+
+
+def init(app_name: str, store_path: str = user_home, config_path: str = "./config"):
+    global _initialized_app_name
+    if _initialized_app_name == app_name:
+        return
+
+    if _initialized_app_name is not None:
+        raise ValueError(f"App {app_name} already initialized with {_initialized_app_name}")
+    _initialized_app_name = app_name
+    try:
+        real_store_path = path.join(store_path, "." + app_name)
+        state.init(real_store_path, ".state")
+        profile.init(real_store_path)
+        config.init(config_path)
+
+    except Exception as e:
+        # critical errors, must print stack trace.
+        if _need_stack_trace(e):
+            raise e
+        else:
+            # Other errors, no stack.
+            from .util import panic
+
+            panic(e)
+
+
+# init default with env if configured
+_app_name = os.environ.get("CTXP_APP_NAME")
+if _app_name:
+    init(_app_name)
+
+
+def app_name():
+    dir_name = path.dirname(state._file._path)
+    name = dir_name[dir_name.rindex(os.sep) + 1 :]
+    if name.startswith("."):
+        return name[1:]
+    raise ValueError("Unable to determine app name: " + dir_name)
+
+
+def init_cli(main_cli: click.Group, commands_dir: str = "./cmds"):
+    try:
+        telemetry.start(_initialized_app_name)
+        ret = cli_processor.init(main_cli, commands_dir)
+        telemetry.end()
+        return ret
+    except BaseException as e:
+        telemetry.end(error=e)
+        if _need_stack_trace(e):
+            raise e
+        else:
+            from .util import panic
+
+            panic(e)
+
+
+def _need_stack_trace(e) -> bool:
+    program_errors = [
+        LookupError,
+        TypeError,
+        ValueError,
+        ArithmeticError,
+        NameError,
+        SyntaxError,
+        KeyError,
+        AttributeError,
+    ]
+    for t in program_errors:
+        if isinstance(e, t):
+            return True
+    return False

hcs_core/ctxp/built_in_cmds/_ut.py

@@ -14,6 +14,7 @@ limitations under the License.
 """
 
 import click
+
 import hcs_core.ctxp as ctxp
 import hcs_core.ctxp.cli_options as cli
 import hcs_core.ctxp.util as util
@@ -43,11 +44,11 @@ def echo_obj(opt: str, id: str):
 
 @cli_test.command()
 @click.option("--opt")
-@click.argument("ids", nargs=-1)
+@click.argument("obj_ids", nargs=-1)
 @cli.formatter(_format_custom_table)
-def echo_obj_list(opt: str, ids: tuple[str]):
+def echo_obj_list(opt: str, obj_ids: tuple[str]):
     ret = []
-    for i in ids:
+    for i in obj_ids:
         ret.append({"id": i, "opt": opt})
     return ret
 

hcs_core/ctxp/built_in_cmds/context.py

@@ -14,6 +14,7 @@ limitations under the License.
 """
 
 import click
+
 import hcs_core.ctxp as ctxp
 import hcs_core.ctxp.util as util
 
@@ -47,7 +48,7 @@ def get(name: str, key: str):
 @click.argument("name")
 @click.argument("key_value")  # 'key value pair, example: k1=v1'
 def set(name: str, key_value: str):
-    """Set a context object by name."""
+    """Set a context property by name."""
     parts = key_value.split("=")
     if len(parts) != 2:
         ctxp.panic("Invalid KEY_VALUE format. Valid example: key1=value1")
@@ -57,6 +58,20 @@ def set(name: str, key_value: str):
     ctxp.context.set(name, data)
 
 
+@context.command()
+@click.argument("name")
+@click.argument("key")
+def unset(name: str, key: str):
+    """Unset a context property by name."""
+    data = ctxp.context.get(name, default=None)
+    if data is None:
+        return
+    data.pop(key, None)
+    if len(data) == 0:
+        return ctxp.context.delete(name)
+    return ctxp.context.set(name, data)
+
+
 @context.command()
 @click.argument("name")
 def delete(name: str):

hcs_core/ctxp/built_in_cmds/profile.py

@@ -13,11 +13,13 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-import click
-import sys
 import json
+import sys
+
+import click
 import questionary
-from hcs_core.ctxp import util, panic, profile, cli_processor
+
+from hcs_core.ctxp import cli_options, cli_processor, panic, profile, util
 
 
 @click.group(name="profile", cls=cli_processor.LazyGroup)
@@ -37,8 +39,10 @@ def use(name: str):
     """Switch to a specific profile. If no name specified, launch interactive list to choose profile."""
 
     if name:
-        if profile.use(name) is None:
+        p = profile.use(name)
+        if p is None:
             panic("No such profile: " + name)
+        return profile.get(name)
     else:
         current = profile.name()
         choices = profile.names()
@@ -49,6 +53,7 @@ def use(name: str):
         if ret:
             if profile.use(ret) is None:
                 panic("No such profile: " + name)
+            return profile.current()
         else:
             # aborted
             return "", 1
@@ -57,7 +62,8 @@ def use(name: str):
 @profile_cmd_group.command()
 @click.option("--from-name", "-f", required=False)
 @click.option("--to-name", "-t", required=True)
-def copy(from_name: str, to_name: str):
+@click.option("--no-edit", "-e", required=False, is_flag=True, help="Edit the profile after copying.")
+def copy(from_name: str, to_name: str, no_edit: bool):
     """Copy profile."""
 
     if not from_name:
@@ -68,7 +74,11 @@ def copy(from_name: str, to_name: str):
         panic("No such profile: " + from_name)
     if profile.exists(to_name):
         panic("Profile already exists: " + to_name)
-    profile.create(to_name, data, True)
+    data = profile.create(to_name, data, True)
+
+    if no_edit:
+        return data
+    util.launch_text_editor(profile.file(to_name))
 
 
 @profile_cmd_group.command()
@@ -78,9 +88,7 @@ def get(name: str):
     if name:
         data = profile.get(name)
         if data is None:
-            panic(
-                "Profile not found. Use 'hcs profile list' to show available profiles, or 'hcs profile init' to create one."
-            )
+            panic("Profile not found. Use 'hcs profile list' to show available profiles, or 'hcs profile init' to create one.")
     else:
         data = profile.current()
         if data is None:
@@ -92,9 +100,20 @@ def get(name: str):
 
 
 @profile_cmd_group.command()
-@click.argument("name")
-def delete(name: str):
+@cli_options.confirm
+@click.argument("name", required=False)
+def delete(confirm: bool, name: str):
     """Delete a profile by name."""
+    if not name:
+        name = profile.name()
+
+    if not profile.exists(name):
+        return
+    if not confirm:
+        question = f"Are you sure to delete profile '{name}'?"
+        if not questionary.confirm(question, default=False).ask():
+            click.echo("Aborted")
+            return
     profile.delete(name)
 
 

hcs_core/ctxp/cli_options.py

@@ -13,8 +13,9 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-import click
+import os
 
+import click
 
 verbose = click.option(
     "--verbose",
@@ -28,7 +29,7 @@ verbose = click.option(
 output = click.option(
     "--output",
     "-o",
-    type=click.Choice(["json", "json-compact", "yaml", "text", "table"]),
+    type=click.Choice(["json", "json-compact", "yaml", "yml", "table", "t", "text"], case_sensitive=False),
     default=None,
     hidden=True,
     help="Specify output format",
@@ -42,13 +43,22 @@ field = click.option(
     help="Specify fields to output, in comma separated field names.",
 )
 
+exclude_field = click.option(
+    "--exclude-field",
+    type=str,
+    required=False,
+    hidden=True,
+    help="Specify fields to exclude from output, in comma separated field names.",
+)
+
 wait = click.option(
     "--wait",
     "-w",
     type=str,
-    required=False,
+    is_flag=False,
+    flag_value="1m",
     default="0",
-    help="Wait time. E.g. '30s', or '5m'. Default: 10m. Specify '0' to disable waiting and return immediately.",
+    help="Wait time. E.g. '30s', or '5m'. Default: 1m.",
 )
 
 search = click.option(
@@ -66,12 +76,11 @@ sort = click.option(
     help="Ascending/Descending. Format is property,{asc|desc} and default is ascending",
 )
 
-limit = click.option(
-    "--limit", "-l", type=int, required=False, default=20, help="Optionally, specify the number of records to fetch."
-)
+limit = click.option("--limit", "-l", type=int, required=False, default=100, help="Optionally, specify the number of records to fetch.")
 
-id_only = click.option(
-    "--id-only",
+ids = click.option(
+    "--ids",
+    "--id-only",  # to be removed.
     is_flag=True,
     type=bool,
     required=False,
@@ -92,14 +101,26 @@ first = click.option(
 
 force = click.option("--force/--grace", type=bool, default=True, help="Specify deletion mode: forceful, or graceful.")
 
-confirm = click.option(
-    "--confirm/--dry-run", "-y", type=bool, default=False, help="Confirm the operation without prompt."
+confirm = click.option("--confirm/--prompt", "-y", type=bool, default=False, help="Confirm the operation without prompt.")
+
+env = click.option(
+    "--env",
+    multiple=True,
+    type=str,
+    required=False,
+    help="Alternative explicit in-line environment variable override in KEY=VALUE format.",
 )
 
 
-def formatter(custom_fn):
+def apply_env(envs):
+    for kv in envs:
+        k, v = kv.split("=", 1)
+        os.environ[k.strip()] = v.strip()
+
+
+def formatter(formatter=None, columns=None):
     def decorator(f):
-        f.formatter = custom_fn
+        f.formatter = formatter if formatter else columns
         return f
 
     return decorator

hcs_core/ctxp/cli_processor.py

@@ -13,17 +13,18 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-import click
-import sys
-from click.core import Group
-import os.path as path
-import os
-import re
 import importlib
 import importlib.util
+import os
+import os.path as path
+import re
+import sys
 from pathlib import Path
-from .util import print_output, print_error, validate_error_return, avoid_trace_for_ctrl_c
-from .extension import ensure_extension
+
+import click
+from click.core import Group
+
+from .util import avoid_trace_for_ctrl_c, default_table_formatter, print_error, print_output, validate_error_return
 
 _eager_loading = os.environ.get("_CTXP_EAGER_LOAD")
 if _eager_loading:
@@ -59,6 +60,8 @@ class LazyGroup(click.Group):
 
     def _ensure_extension(self):
         if self._extension:
+            from .extension import ensure_extension
+
             ensure_extension(self._extension)
 
 
@@ -73,6 +76,7 @@ def _ensure_sub_group(current: Group, mod_path: Path):
     meta = _read_group_meta(mod_path)
     help = meta.get("help")
     extension = meta.get("extension")
+    hidden = meta.get("hidden", False)
 
     subgroup = current.commands.get(name)
     if subgroup and isinstance(subgroup, Group):
@@ -80,7 +84,7 @@ def _ensure_sub_group(current: Group, mod_path: Path):
             subgroup.mod_path = mod_path
         return subgroup
 
-    subgroup = LazyGroup(extension=extension, name=name, help=help, mod_path=mod_path)
+    subgroup = LazyGroup(extension=extension, name=name, help=help, mod_path=mod_path, hidden=hidden)
     current.add_command(subgroup)
     return subgroup
 
@@ -164,32 +168,41 @@ def _import_cmd_file(mod_path: Path, parent: click.core.Group):
 # Create a new decorator that combines the individual decorators
 def _default_io(cmd: click.Command):
 
-    from .cli_options import output, field, id_only, first
+    from .cli_options import exclude_field, field, first, ids, output
 
     cmd = output(cmd)
     # cmd = cli_options.verbose(cmd)
     cmd = field(cmd)
-    cmd = id_only(cmd)
+    cmd = ids(cmd)
     cmd = first(cmd)
+    cmd = exclude_field(cmd)
     callback = cmd.callback
 
     def inner(*args, **kwargs):
         io_args = {
             "output": kwargs.pop("output"),
-            #'verbose': kwargs.pop('verbose'),
+            # 'verbose': kwargs.pop('verbose'),
             "field": kwargs.pop("field"),
-            "id_only": kwargs.pop("id_only"),
+            "ids": kwargs.pop("ids"),
             "first": kwargs.pop("first"),
+            "exclude_field": kwargs.pop("exclude_field"),
         }
-        if io_args["output"] == "table":
+        ctx = click.get_current_context()
+        from .telemetry import update as telemetry_update
 
-            def _format(data):
-                if not hasattr(callback, "formatter"):
-                    from .util import CtxpException
+        telemetry_update(ctx.command_path, ctx.params)
 
-                    raise CtxpException("Table output is specified, but no custom formatter specified on the command.")
-                formatter = callback.__getattribute__("formatter")
-                return formatter(data)
+        if io_args["output"] == "table" or io_args["output"] == "t":
+
+            def _format(data):
+                if hasattr(callback, "formatter"):
+                    formatter = callback.__getattribute__("formatter")
+                else:
+                    formatter = default_table_formatter
+                if isinstance(formatter, dict):
+                    return default_table_formatter(data, formatter)
+                else:
+                    return formatter(data)
 
             io_args["format"] = _format
         ret = callback(*args, **kwargs)

hcs_core/ctxp/cmd_util.py

@@ -0,0 +1,87 @@
+import logging
+import os
+import os.path
+import subprocess
+
+log = logging.getLogger(__name__)
+
+
+def run_cmd(cmd, shell: bool = True):
+    cmd_text = " ".join(cmd)
+    log.info(f"Running command: {cmd_text}")
+    result = {}
+    result["command"] = cmd_text
+    # proc = subprocess.run(cmd, shell=shell, check=False, capture_output=True, timeout=60, encoding="utf-8")
+    proc = subprocess.run(cmd, shell=shell, check=False, timeout=60, **subprocess_args())
+    result["stdout"] = proc.stdout.decode("utf-8")
+    result["stderr"] = proc.stderr.decode("utf-8")
+    result["returnCode"] = proc.returncode
+    return result
+
+
+# Create a set of arguments which make a ``subprocess.Popen`` (and
+# variants) call work with or without Pyinstaller, ``--noconsole`` or
+# not, on Windows and Linux. Typical use::
+#
+#   subprocess.call(['program_to_run', 'arg_1'], **subprocess_args())
+#
+# When calling ``check_output``::
+#
+#   subprocess.check_output(['program_to_run', 'arg_1'],
+#                           **subprocess_args(False))
+def subprocess_args(include_stdout=True):
+    # The following is true only on Windows.
+    if hasattr(subprocess, "STARTUPINFO"):
+        # On Windows, subprocess calls will pop up a command window by default
+        # when run from Pyinstaller with the ``--noconsole`` option. Avoid this
+        # distraction.
+        si = subprocess.STARTUPINFO()
+        si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+        # Windows doesn't search the path by default. Pass it an environment so
+        # it will.
+        env = os.environ
+    else:
+        si = None
+        env = None
+
+    # ``subprocess.check_output`` doesn't allow specifying ``stdout``::
+    #
+    #   Traceback (most recent call last):
+    #     File "test_subprocess.py", line 58, in <module>
+    #       **subprocess_args(stdout=None))
+    #     File "C:\Python27\lib\subprocess.py", line 567, in check_output
+    #       raise ValueError('stdout argument not allowed, it will be overridden.')
+    #   ValueError: stdout argument not allowed, it will be overridden.
+    #
+    # So, add it only if it's needed.
+    if include_stdout:
+        ret = {"stdout": subprocess.PIPE}
+    else:
+        ret = {}
+
+    # On Windows, running this from the binary produced by Pyinstaller
+    # with the ``--noconsole`` option requires redirecting everything
+    # (stdin, stdout, stderr) to avoid an OSError exception
+    # "[Error 6] the handle is invalid."
+    ret.update(
+        {
+            "stdin": subprocess.PIPE,
+            "stderr": subprocess.PIPE,
+            "startupinfo": si,
+            "env": env,
+        }
+    )
+    return ret
+
+
+# A simple test routine. Compare this output when run by Python, Pyinstaller,
+# and Pyinstaller ``--noconsole``.
+if __name__ == "__main__":
+    # Save the output from invoking Python to a text file. This is the only
+    # option when running with ``--noconsole``.
+    with open("out.txt", "w") as f:
+        try:
+            txt = subprocess.check_output(["python", "--help"], **subprocess_args(False))
+            f.write(txt)
+        except OSError as e:
+            f.write("Failed: " + str(e))

hcs_core/ctxp/config.py

@@ -13,8 +13,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-from .jsondot import dotdict
 from .fstore import fstore
+from .jsondot import dotdict
 
 _store_impl: fstore = None