vantage6 5.0.0a36__py3-none-any.whl → 5.0.0a38__py3-none-any.whl

vantage6/cli/common/decorator.py

@@ -6,7 +6,8 @@ import click
 from vantage6.common import error
 from vantage6.common.globals import InstanceType
 
-from vantage6.cli.configuration_wizard import select_configuration_questionaire
+from vantage6.cli.common.utils import extract_name_and_is_sandbox
+from vantage6.cli.configuration_create import select_configuration_questionnaire
 from vantage6.cli.context import get_context, select_context_class
 
 
@@ -14,6 +15,8 @@ def click_insert_context(
     type_: InstanceType,
     include_name: bool = False,
     include_system_folders: bool = False,
+    is_sandbox: bool = False,
+    sandbox_param: str | None = None,
 ) -> callable:
     """
     Supply the Click function with an additional context parameter. The context
@@ -27,6 +30,12 @@ def click_insert_context(
         Include the name of the configuration as an argument
     include_system_folders : bool
         Include whether or not to use the system folders as an argument
+    is_sandbox : bool
+        Include whether or not to use the sandbox configurations as an argument
+    sandbox_param : str | None
+        Name of a Click option/parameter in the command function whose boolean
+        value should determine sandbox mode at runtime. If provided, this value
+        overrides the static is_sandbox parameter.
 
     Returns
     -------
@@ -58,7 +67,7 @@ def click_insert_context(
             "--user",
             "system_folders",
             flag_value=False,
-            default=False if type_ == InstanceType.NODE else True,
+            default=False if type_ == InstanceType.NODE or is_sandbox else True,
             help="Use user folders instead of system folders",
         )
         @wraps(func)
@@ -74,6 +83,16 @@ def click_insert_context(
                 Decorated function
             """
             ctx_class = select_context_class(type_)
+
+            # Determine sandbox mode, preferring runtime option when provided
+            runtime_is_sandbox = is_sandbox
+            if sandbox_param is not None:
+                # Pop to avoid passing unknown kwarg to the wrapped function
+                runtime_is_sandbox = bool(kwargs.pop(sandbox_param, False))
+            name, runtime_is_sandbox = extract_name_and_is_sandbox(
+                name, runtime_is_sandbox
+            )
+
             # path to configuration file always overrides name
             if config:
                 ctx = ctx_class.from_external_config_file(config, system_folders)
@@ -87,12 +106,14 @@ def click_insert_context(
                 if not name:
                     try:
                         # select configuration if none supplied
-                        name = select_configuration_questionaire(type_, system_folders)
+                        name = select_configuration_questionnaire(
+                            type_, system_folders, runtime_is_sandbox
+                        )
                     except Exception:
                         error("No configurations could be found!")
                         exit(1)
 
-                ctx = get_context(type_, name, system_folders)
+                ctx = get_context(type_, name, system_folders, runtime_is_sandbox)
             extra_args = []
             if include_name:
                 if not name:

vantage6/cli/common/list.py

@@ -0,0 +1,68 @@
+import click
+from colorama import Fore, Style
+
+from vantage6.common import warning
+from vantage6.common.globals import (
+    APPNAME,
+    SANDBOX_SUFFIX,
+    InstanceType,
+)
+
+from vantage6.cli.common.utils import find_running_service_names
+from vantage6.cli.context import select_context_class
+
+
+def get_configuration_list(instance_type: InstanceType) -> None:
+    """
+    Print list of available server configurations.
+
+    Parameters
+    ----------
+    instance_type : InstanceType
+        The type of instance to get the configurations for
+    """
+    ctx_class = select_context_class(instance_type)
+
+    running_server_names = find_running_service_names(instance_type)
+    header = "\nName" + (21 * " ") + "Status" + (10 * " ") + "System/User"
+
+    click.echo(header)
+    click.echo("-" * len(header))
+
+    running = Fore.GREEN + "Running" + Style.RESET_ALL
+    stopped = Fore.RED + "Not running" + Style.RESET_ALL
+
+    # system folders
+    configs, failed_imports_system = ctx_class.available_configurations(
+        system_folders=True
+    )
+    for config in configs:
+        config.name = config.name.replace(SANDBOX_SUFFIX, "")
+        status = (
+            running
+            if f"{APPNAME}-{config.name}-system-{instance_type.value}"
+            in running_server_names
+            else stopped
+        )
+        click.echo(f"{config.name:25}{status:25} System ")
+
+    # user folders
+    configs, failed_imports_user = ctx_class.available_configurations(
+        system_folders=False
+    )
+    for config in configs:
+        config.name = config.name.replace(SANDBOX_SUFFIX, "")
+        status = (
+            running
+            if f"{APPNAME}-{config.name}-user-{instance_type.value}"
+            in running_server_names
+            else stopped
+        )
+        click.echo(f"{config.name:25}{status:25} User   ")
+
+    click.echo("-" * 85)
+    if len(failed_imports_system) + len(failed_imports_user):
+        warning(
+            f"{Fore.RED}Failed imports: "
+            f"{len(failed_imports_system) + len(failed_imports_user)}{Style.RESET_ALL}"
+        )

vantage6/cli/common/new.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+
 from colorama import Fore, Style
 
 from vantage6.common import ensure_config_dir_writable, error, info
@@ -5,26 +7,30 @@ from vantage6.common.globals import InstanceType
 
 from vantage6.cli.common.utils import get_main_cli_command_name
 from vantage6.cli.config import CliConfig
-from vantage6.cli.configuration_wizard import configuration_wizard
+from vantage6.cli.configuration_create import make_configuration
 from vantage6.cli.context import select_context_class
 from vantage6.cli.utils import check_config_name_allowed, prompt_config_name
 
 
 def new(
-    questionnaire_function: callable,
+    config_producing_func: callable,
+    config_producing_func_args: tuple,
     name: str,
     system_folders: bool,
     namespace: str,
     context: str,
     type_: InstanceType,
-) -> None:
+    is_sandbox: bool = False,
+) -> Path | None:
     """
     Create a new configuration.
 
     Parameters
     ----------
-    questionnaire_function : callable
+    config_producing_func : callable
         Function to generate the configuration
+    config_producing_func_args : tuple
+        Arguments to pass to the config producing function
     name : str
         Name of the configuration
     system_folders : bool
@@ -35,6 +41,13 @@ def new(
         Context to use
     type_ : InstanceType
         Type of the configuration (node, server, algorithm store, etc)
+    is_sandbox : bool
+        Whether to create a sandbox configuration or not
+
+    Returns
+    -------
+    Path | None
+        Path to the configuration file. None if the process is aborted for any reason.
     """
     cli_config = CliConfig()
     context, namespace = cli_config.compare_changes_config(
@@ -50,11 +63,12 @@ def new(
     # check that this config does not exist
     ctx_class = select_context_class(type_)
     try:
-        if ctx_class.config_exists(name, system_folders):
+        if ctx_class.config_exists(name, system_folders, is_sandbox):
             error(f"Configuration {Fore.RED}{name}{Style.RESET_ALL} already exists!")
             exit(1)
     except Exception as e:
         error(e)
+
         exit(1)
 
     command_name = get_main_cli_command_name(type_)
@@ -70,8 +84,13 @@ def new(
 
     # create config in ctx location
     try:
-        cfg_file = configuration_wizard(
-            questionnaire_function, type_, name, system_folders
+        cfg_file = make_configuration(
+            config_producing_func=config_producing_func,
+            config_producing_func_args=config_producing_func_args,
+            type_=type_,
+            instance_name=name,
+            system_folders=system_folders,
+            is_sandbox=is_sandbox,
         )
     except KeyboardInterrupt:
         error("Configuration creation aborted.")
@@ -83,3 +102,4 @@ def new(
         f"You can start the {command_name} by running {Fore.GREEN}v6 {command_name} "
         f"start {flag}{Style.RESET_ALL}"
     )
+    return cfg_file

vantage6/cli/common/remove.py

@@ -24,6 +24,24 @@ def execute_remove(
     system_folders: bool,
     force: bool,
 ) -> None:
+    """
+    Function to remove a vantage6 service instance.
+
+    Parameters
+    ----------
+    ctx : AppContext
+        App context object
+    instance_type : InstanceType
+        Type of instance that is checked
+    infra_component : InfraComponentName
+        The infra component of the service
+    name : str
+        Name of the instance
+    system_folders : bool
+        Whether to use system folders or user folders
+    force : bool
+        Whether to ask for confirmation before removing or not
+    """
     if check_running(ctx.helm_release_name, instance_type, name, system_folders):
         error(
             f"The {infra_component.value} {name} is still running! Please stop the "

vantage6/cli/common/start.py

@@ -19,13 +19,11 @@ from vantage6.common.globals import (
     DEFAULT_NODE_IMAGE,
     DEFAULT_SERVER_IMAGE,
     DEFAULT_UI_IMAGE,
+    LOCALHOST,
     InstanceType,
 )
 
-from vantage6.cli.common.utils import (
-    check_running,
-    select_context_and_namespace,
-)
+from vantage6.cli.common.utils import check_running
 from vantage6.cli.globals import ChartName
 from vantage6.cli.utils import check_config_name_allowed, validate_input_cmd_args
 
@@ -35,8 +33,6 @@ def prestart_checks(
     instance_type: InstanceType,
     name: str,
     system_folders: bool,
-    context: str,
-    namespace: str,
 ) -> None:
     """
     Run pre-start checks for an instance.
@@ -48,11 +44,6 @@ def prestart_checks(
         error(f"Instance '{name}' is already running.")
         exit(1)
 
-    context, namespace = select_context_and_namespace(
-        context=context,
-        namespace=namespace,
-    )
-
 
 def pull_infra_image(
     client: DockerClient, image: str, instance_type: InstanceType
@@ -142,6 +133,7 @@ def helm_install(
     values_file: str | PathLike | None = None,
     context: str | None = None,
     namespace: str | None = None,
+    local_chart_dir: str | None = None,
 ) -> None:
     """
     Manage the `helm install` command.
@@ -158,6 +150,8 @@ def helm_install(
         The Kubernetes context to use.
     namespace : str, optional
         The Kubernetes namespace to use.
+    local_chart_dir : str, optional
+        The local directory containing the Helm charts.
     """
     # Input validation
     validate_input_cmd_args(release_name, "release name")
@@ -171,17 +165,28 @@ def helm_install(
     validate_input_cmd_args(context, "context name", allow_none=True)
     validate_input_cmd_args(namespace, "namespace name", allow_none=True)
 
+    if local_chart_dir and local_chart_dir.rstrip("/").endswith(chart_name.value):
+        local_chart_dir = str(Path(local_chart_dir).parent)
+
     # Create the command
-    command = [
-        "helm",
-        "install",
-        release_name,
-        chart_name,
-        "--repo",
-        DEFAULT_CHART_REPO,
-        # TODO v5+ remove this flag when we have a stable release
-        "--devel",  # ensure using latest version including pre-releases
-    ]
+    if local_chart_dir:
+        command = [
+            "helm",
+            "install",
+            release_name,
+            f"{local_chart_dir}/{chart_name.value}",
+        ]
+    else:
+        command = [
+            "helm",
+            "install",
+            release_name,
+            chart_name,
+            "--repo",
+            DEFAULT_CHART_REPO,
+            # TODO v5+ remove this flag when we have a stable release
+            "--devel",
+        ]
 
     if values_file:
         command.extend(["-f", str(values_file)])
@@ -217,7 +222,7 @@ def start_port_forward(
     service_name: str,
     service_port: int,
     port: int,
-    ip: str | None,
+    ip: str = LOCALHOST,
     context: str | None = None,
     namespace: str | None = None,
 ) -> None:
@@ -232,8 +237,8 @@ def start_port_forward(
         The port on the service to forward.
     port : int
         The port to listen on.
-    ip : str | None
-        The IP address to listen on. If None, defaults to localhost.
+    ip : str
+        The IP address to listen on. Defaults to localhost.
     context : str | None
         The Kubernetes context to use.
     namespace : str | None
@@ -264,20 +269,22 @@ def start_port_forward(
     timeout = 300  # seconds
     while time.time() - start_time < timeout:
         try:
-            result = (
-                subprocess.check_output(
-                    [
-                        "kubectl",
-                        "get",
-                        "endpoints",
-                        service_name,
-                        "-o",
-                        "jsonpath={.subsets[*].addresses[*].ip}",
-                    ]
-                )
-                .decode()
-                .strip()
-            )
+            command = [
+                "kubectl",
+                "get",
+                "endpoints",
+                service_name,
+                "-o",
+                "jsonpath={.subsets[*].addresses[*].ip}",
+            ]
+
+            if context:
+                command.extend(["--context", context])
+
+            if namespace:
+                command.extend(["--namespace", namespace])
+
+            result = subprocess.check_output(command).decode().strip()
 
             if result:
                 info(f"Service '{service_name}' is ready.")
@@ -288,13 +295,14 @@ def start_port_forward(
         time.sleep(2)
     else:
         error(
-            f"Timeout: Service '{service_name}' has no ready endpoints after {timeout} seconds."
+            f"Timeout: Service '{service_name}' has no ready endpoints after {timeout} "
+            "seconds."
         )
         return
 
     # Create the port forwarding command
     if not ip:
-        ip = "localhost"
+        ip = LOCALHOST
 
     command = [
         "kubectl",

vantage6/cli/common/stop.py

@@ -8,6 +8,7 @@ from vantage6.common import error, info, warning
 from vantage6.common.globals import InstanceType
 
 from vantage6.cli.common.utils import (
+    extract_name_and_is_sandbox,
     find_running_service_names,
     select_context_and_namespace,
     select_running_service,
@@ -26,6 +27,8 @@ def execute_stop(
     namespace: str,
     context: str,
     system_folders: bool,
+    is_sandbox: bool = False,
+    stop_function_args: dict | None = None,
 ):
     """
     Execute the stop function for a given instance type and infra component.
@@ -41,19 +44,25 @@ def execute_stop(
     stop_all : bool
         Whether to stop all services.
     to_stop : str | None
-        The name of the service to stop.
+        The name of the service to stop. If None, the user will be asked to select a
+        service.
     namespace : str
         The namespace of the service.
     context : str
         The context of the service.
     system_folders : bool
         Whether to use system folders.
+    is_sandbox : bool
+        Whether the configuration is a sandbox configuration, by default False
+    stop_function_args : dict | None
+        Additional arguments to pass to the stop function
     """
+    if stop_function_args is None:
+        stop_function_args = {}
     context, namespace = select_context_and_namespace(
         context=context,
         namespace=namespace,
     )
-
     running_services = find_running_service_names(
         instance_type=instance_type,
         only_system_folders=system_folders,
@@ -73,11 +82,14 @@ def execute_stop(
         if not to_stop:
             helm_name = select_running_service(running_services, instance_type)
         else:
-            ctx = get_context(instance_type, to_stop, system_folders)
+            to_stop, is_sandbox = extract_name_and_is_sandbox(to_stop, is_sandbox)
+            ctx = get_context(
+                instance_type, to_stop, system_folders, is_sandbox=is_sandbox
+            )
             helm_name = ctx.helm_release_name
 
         if helm_name in running_services:
-            stop_function(helm_name, namespace, context)
+            stop_function(helm_name, namespace, context, **stop_function_args)
             info(
                 f"Stopped the {Fore.GREEN}{helm_name}{Style.RESET_ALL} {infra_component.value}."
             )

vantage6/cli/common/utils.py

@@ -1,19 +1,20 @@
 import json
 import subprocess
 from pathlib import Path
-from subprocess import Popen
 from typing import Iterable
 
-import click
 import docker
 import questionary as q
-from colorama import Fore, Style
 
-from vantage6.common import error, warning
-from vantage6.common.globals import APPNAME, STRING_ENCODING, InstanceType
+from vantage6.common import error
+from vantage6.common.globals import (
+    APPNAME,
+    SANDBOX_SUFFIX,
+    STRING_ENCODING,
+    InstanceType,
+)
 
 from vantage6.cli.config import CliConfig
-from vantage6.cli.context import select_context_class
 from vantage6.cli.globals import CLICommandName
 from vantage6.cli.utils import validate_input_cmd_args
 
@@ -66,6 +67,7 @@ def find_running_service_names(
     only_user_folders: bool = False,
     context: str | None = None,
     namespace: str | None = None,
+    sandbox: bool = False,
 ) -> list[str]:
     """
     List running Vantage6 servers.
@@ -82,6 +84,8 @@ def find_running_service_names(
         The Kubernetes context to use.
     namespace : str, optional
         The Kubernetes namespace to use.
+    sandbox : bool, optional
+        Whether to look for sandbox services or not. By default False.
 
     Returns
     -------
@@ -248,60 +252,6 @@ def get_running_servers(
     return [server.name for server in running_servers]
 
 
-def get_server_configuration_list(instance_type: InstanceType) -> None:
-    """
-    Print list of available server configurations.
-
-    Parameters
-    ----------
-    instance_type : InstanceType
-        The type of instance to get the configurations for
-    """
-    ctx_class = select_context_class(instance_type)
-
-    running_server_names = find_running_service_names(instance_type)
-    header = "\nName" + (21 * " ") + "Status" + (10 * " ") + "System/User"
-
-    click.echo(header)
-    click.echo("-" * len(header))
-
-    running = Fore.GREEN + "Running" + Style.RESET_ALL
-    stopped = Fore.RED + "Not running" + Style.RESET_ALL
-
-    # system folders
-    configs, failed_imports_system = ctx_class.available_configurations(
-        system_folders=True
-    )
-    for config in configs:
-        status = (
-            running
-            if f"{APPNAME}-{config.name}-system-{instance_type.value}"
-            in running_server_names
-            else stopped
-        )
-        click.echo(f"{config.name:25}{status:25} System ")
-
-    # user folders
-    configs, failed_imports_user = ctx_class.available_configurations(
-        system_folders=False
-    )
-    for config in configs:
-        status = (
-            running
-            if f"{APPNAME}-{config.name}-user-{instance_type.value}"
-            in running_server_names
-            else stopped
-        )
-        click.echo(f"{config.name:25}{status:25} User   ")
-
-    click.echo("-" * 85)
-    if len(failed_imports_system) + len(failed_imports_user):
-        warning(
-            f"{Fore.RED}Failed imports: "
-            f"{len(failed_imports_system) + len(failed_imports_user)}{Style.RESET_ALL}"
-        )
-
-
 def print_log_worker(logs_stream: Iterable[bytes]) -> None:
     """
     Print the logs from the logs stream.
@@ -351,20 +301,6 @@ def get_config_name_from_service_name(service_name: str) -> str:
     return "-".join(service_name.split("-")[1:-2])
 
 
-def attach_logs(*labels: list[str]) -> None:
-    """
-    Attach to the logs of the given labels.
-
-    Parameters
-    ----------
-    labels : list[str]
-        The labels to attach to
-    """
-    command = ["kubectl", "logs", "--follow", "--selector", ",".join(labels)]
-    process = Popen(command, stdout=None, stderr=None)
-    process.wait()
-
-
 def get_main_cli_command_name(instance_type: InstanceType) -> str:
     """
     Get the main CLI command name for a given instance type.
@@ -414,3 +350,58 @@ def check_running(
         only_user_folders=not system_folders,
     )
     return helm_release_name in running_services
+
+
+def get_config_name_from_helm_release_name(
+    helm_release_name: str, is_store: bool = False
+) -> str:
+    """
+    Get the config name from a helm release name.
+
+    Parameters
+    ----------
+    helm_release_name : str
+        The name of the Helm release
+    is_store : bool, optional
+        Whether the instance is a store or not. By default False.
+
+    Returns
+    -------
+    str
+        The config name
+    """
+    # helm release name is structured as:
+    # f"{APPNAME}-{name}-{scope}-{instance_type}"
+    # we want to get the name from the service name
+    if is_store:
+        # for store, the instance type is `algorithm-store` which contains an additional
+        # hyphen
+        return "-".join(helm_release_name.split("-")[1:-3])
+    else:
+        return "-".join(helm_release_name.split("-")[1:-2])
+
+
+def extract_name_and_is_sandbox(name: str | None, is_sandbox: bool) -> tuple[str, bool]:
+    """
+    Extract the name and is_sandbox from the name.
+
+    Note that the name may be None: this occurs before when this function is called
+    before the user has selected a name. This scenario is fine because when the user
+    selects a name interactively, the name never ends with the .sandbox suffix.
+
+    Parameters
+    ----------
+    name : str | None
+        The name of the instance
+    is_sandbox : bool
+        Whether the instance is a sandbox instance
+
+    Returns
+    -------
+    tuple[str, bool]
+        The name and is_sandbox
+    """
+    if name and name.endswith(SANDBOX_SUFFIX):
+        return name[: -len(SANDBOX_SUFFIX)], True
+    else:
+        return name, is_sandbox