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

vantage6/cli/common/version.py

@@ -0,0 +1,82 @@
+from vantage6.common import error
+from vantage6.common.globals import InstanceType
+
+from vantage6.cli.common.utils import (
+    find_running_service_names,
+    get_config_name_from_helm_release_name,
+    select_context_and_namespace,
+    select_running_service,
+)
+from vantage6.cli.context import get_context
+from vantage6.cli.context.algorithm_store import AlgorithmStoreContext
+from vantage6.cli.context.node import NodeContext
+from vantage6.cli.context.server import ServerContext
+
+
+def get_and_select_ctx(
+    instance_type: InstanceType,
+    name: str,
+    system_folders: bool,
+    context: str,
+    namespace: str,
+    is_sandbox: bool,
+) -> ServerContext | NodeContext | AlgorithmStoreContext:
+    """
+    Get and select the context for the given instance type.
+
+    Parameters
+    ----------
+    instance_type : InstanceType
+        The type of instance to get the context for
+    name : str
+        The name of the instance
+    system_folders : bool
+        Whether to use system folders or not
+    context : str
+        The Kubernetes context to use
+    namespace : str
+        The Kubernetes namespace to use
+    is_sandbox : bool
+        Whether the configuration is a sandbox configuration
+
+    Returns
+    -------
+    ServerContext | NodeContext | AlgorithmStoreContext
+        The context for the given instance type
+    """
+    context, namespace = select_context_and_namespace(
+        context=context,
+        namespace=namespace,
+    )
+    running_services = find_running_service_names(
+        instance_type=instance_type,
+        only_system_folders=False,
+        only_user_folders=False,
+        context=context,
+        namespace=namespace,
+        sandbox=is_sandbox,
+    )
+
+    if not running_services:
+        error(f"No running {instance_type.value}s found.")
+        exit(1)
+
+    if not name:
+        helm_name = select_running_service(running_services, instance_type)
+
+        service_name = get_config_name_from_helm_release_name(
+            helm_name, is_store=(instance_type == InstanceType.ALGORITHM_STORE)
+        )
+        ctx = get_context(
+            instance_type, service_name, system_folders, is_sandbox=is_sandbox
+        )
+
+    else:
+        ctx = get_context(instance_type, name, system_folders, is_sandbox=is_sandbox)
+        helm_name = ctx.helm_release_name
+        service_name = ctx.name
+
+    if helm_name not in running_services:
+        error(f"The {instance_type.value} {service_name} is not running.")
+        exit(1)
+    return ctx

vantage6/cli/config.py

@@ -13,6 +13,8 @@ from vantage6.cli.globals import (
     DEFAULT_CLI_CONFIG_FILE,
 )
 
+_CONTEXT_INFO_PRINTED = False
+
 
 class CliConfig:
     """
@@ -255,6 +257,12 @@ class CliConfig:
             if last_namespace != active_namespace:
                 self.set_last_namespace(namespace=active_namespace)
 
-        info(f"Using    context: {Fore.YELLOW}{active_context}{Style.RESET_ALL}")
-        info(f"Using  namespace: {Fore.YELLOW}{active_namespace}{Style.RESET_ALL}")
+        # only print the context and namespace once. This is to avoid printing it many
+        # times, e.g. in sandbox commands
+        global _CONTEXT_INFO_PRINTED
+        if not _CONTEXT_INFO_PRINTED:
+            info(f"Using    context: {Fore.YELLOW}{active_context}{Style.RESET_ALL}")
+            info(f"Using  namespace: {Fore.YELLOW}{active_namespace}{Style.RESET_ALL}")
+            _CONTEXT_INFO_PRINTED = True
+
         return active_context, active_namespace

vantage6/cli/{configuration_wizard.py → configuration_create.py}

@@ -126,25 +126,31 @@ def _add_production_server_config(config: dict) -> dict:
     return config
 
 
-def configuration_wizard(
-    questionnaire_function: callable,
+def make_configuration(
+    config_producing_func: callable,
+    config_producing_func_args: tuple,
     type_: InstanceType,
     instance_name: str,
     system_folders: bool,
+    is_sandbox: bool = False,
 ) -> Path:
     """
     Create a configuration file for a node or server instance.
 
     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
     type_ : InstanceType
         Type of the instance to create a configuration for
     instance_name : str
         Name of the instance
     system_folders : bool
         Whether to use the system folders or not
+    is_sandbox : bool
+        Whether to create a sandbox configuration or not
 
     Returns
     -------
@@ -154,11 +160,10 @@ def configuration_wizard(
     # for defaults and where to save the config
     dirs = AppContext.instance_folders(type_, instance_name, system_folders)
 
-    # invoke questionaire to create configuration file
-    if type_ == InstanceType.NODE:
-        config = questionnaire_function(dirs, instance_name)
-    else:
-        config = questionnaire_function(instance_name)
+    # invoke function to create configuration file. Usually this is a questionaire
+    # but it can also be a function that immediately returns a dict with the
+    # configuration.
+    config = config_producing_func(*config_producing_func_args)
 
     # in the case of an environment we need to add it to the current
     # configuration. In the case of application we can simply overwrite this
@@ -176,17 +181,19 @@ def configuration_wizard(
         raise ValueError(f"Invalid instance type: {type_}")
 
     if Path(config_file).exists():
-        config_manager = conf_manager.from_file(config_file)
+        config_manager = conf_manager.from_file(config_file, is_sandbox=is_sandbox)
     else:
-        config_manager = conf_manager(instance_name)
+        config_manager = conf_manager(instance_name, is_sandbox=is_sandbox)
 
     config_manager.put(config)
-    config_manager.save(config_file)
+    config_file = config_manager.save(config_file)
 
     return config_file
 
 
-def select_configuration_questionaire(type_: InstanceType, system_folders: bool) -> str:
+def select_configuration_questionnaire(
+    type_: InstanceType, system_folders: bool, is_sandbox: bool = False
+) -> str:
     """
     Ask which configuration the user wants to use. It shows only configurations
     that are in the default folder.
@@ -197,14 +204,15 @@ def select_configuration_questionaire(type_: InstanceType, system_folders: bool)
         Type of the instance to create a configuration for
     system_folders : bool
         Whether to use the system folders or not
-
+    is_sandbox : bool
+        Whether to show only the sandbox configurations or not
     Returns
     -------
     str
         Name of the configuration
     """
     context = select_context_class(type_)
-    configs, _ = context.available_configurations(system_folders)
+    configs, _ = context.available_configurations(system_folders, is_sandbox)
 
     # each collection (file) can contain multiple configs. (e.g. test,
     # dev)

vantage6/cli/configuration_manager.py

@@ -1,3 +1,4 @@
+from pathlib import Path
 from typing import Self
 
 from schema import And, Use
@@ -86,18 +87,18 @@ class NodeConfigurationManager(ConfigurationManager):
         Name of the configuration file.
     """
 
-    def __init__(self, name, *args, **kwargs) -> None:
-        super().__init__(conf_class=NodeConfiguration, name=name)
+    def __init__(self, name: str, is_sandbox: bool = False, *args, **kwargs) -> None:
+        super().__init__(conf_class=NodeConfiguration, name=name, is_sandbox=is_sandbox)
 
     @classmethod
-    def from_file(cls, path: str) -> Self:
+    def from_file(cls, path: Path | str, is_sandbox: bool = False) -> Self:
         """
         Create a new instance of the NodeConfigurationManager from a
         configuration file.
 
         Parameters
         ----------
-        path : str
+        path : str | Path
             Path to the configuration file.
 
         Returns
@@ -105,7 +106,9 @@ class NodeConfigurationManager(ConfigurationManager):
         NodeConfigurationManager
             A new instance of the NodeConfigurationManager.
         """
-        return super().from_file(path, conf_class=NodeConfiguration)
+        return super().from_file(
+            path, conf_class=NodeConfiguration, is_sandbox=is_sandbox
+        )
 
     def get_config_template(self) -> str:
         """
@@ -124,18 +127,20 @@ class ServerConfigurationManager(ConfigurationManager):
         Name of the configuration file.
     """
 
-    def __init__(self, name, *args, **kwargs) -> None:
-        super().__init__(conf_class=ServerConfiguration, name=name)
+    def __init__(self, name: str, is_sandbox: bool = False, *args, **kwargs) -> None:
+        super().__init__(
+            conf_class=ServerConfiguration, name=name, is_sandbox=is_sandbox
+        )
 
     @classmethod
-    def from_file(cls, path) -> Self:
+    def from_file(cls, path: Path | str, is_sandbox: bool = False) -> Self:
         """
         Create a new instance of the ServerConfigurationManager from a
         configuration file.
 
         Parameters
         ----------
-        path : str
+        path : str | Path
             Path to the configuration file.
 
         Returns
@@ -143,7 +148,9 @@ class ServerConfigurationManager(ConfigurationManager):
         ServerConfigurationManager
             A new instance of the ServerConfigurationManager.
         """
-        return super().from_file(path, conf_class=ServerConfiguration)
+        return super().from_file(
+            path, conf_class=ServerConfiguration, is_sandbox=is_sandbox
+        )
 
     def get_config_template(self) -> str:
         """
@@ -167,18 +174,20 @@ class AlgorithmStoreConfigurationManager(ConfigurationManager):
         Name of the configuration file.
     """
 
-    def __init__(self, name, *args, **kwargs) -> None:
-        super().__init__(conf_class=AlgorithmStoreConfiguration, name=name)
+    def __init__(self, name: str, is_sandbox: bool = False, *args, **kwargs) -> None:
+        super().__init__(
+            conf_class=AlgorithmStoreConfiguration, name=name, is_sandbox=is_sandbox
+        )
 
     @classmethod
-    def from_file(cls, path: str) -> Self:
+    def from_file(cls, path: Path | str, is_sandbox: bool = False) -> Self:
         """
         Create a new instance of the AlgorithmStoreConfigurationManager from a
         configuration file.
 
         Parameters
         ----------
-        path : str
+        path : str | Path
             Path to the configuration file.
 
         Returns
@@ -186,7 +195,9 @@ class AlgorithmStoreConfigurationManager(ConfigurationManager):
         AlgorithmStoreConfigurationManager
             A new instance of the AlgorithmStoreConfigurationManager.
         """
-        return super().from_file(path, conf_class=AlgorithmStoreConfiguration)
+        return super().from_file(
+            path, conf_class=AlgorithmStoreConfiguration, is_sandbox=is_sandbox
+        )
 
     def get_config_template(self) -> str:
         """
@@ -208,14 +219,34 @@ class AuthConfigurationManager(ConfigurationManager):
     ----------
     name : str
         Name of the configuration file.
+    is_sandbox : bool, optional
+        Whether the configuration is a sandbox configuration, by default False
     """
 
-    def __init__(self, name, *args, **kwargs):
-        super().__init__(conf_class=AuthConfiguration, name=name)
+    def __init__(self, name, is_sandbox: bool = False, *args, **kwargs):
+        super().__init__(conf_class=AuthConfiguration, name=name, is_sandbox=is_sandbox)
 
     @classmethod
-    def from_file(cls, path: str) -> Self:
-        return super().from_file(path, conf_class=AuthConfiguration)
+    def from_file(cls, path: Path | str, is_sandbox: bool = False) -> Self:
+        """
+        Create a new instance of the AuthConfigurationManager from a
+        configuration file.
+
+        Parameters
+        ----------
+        path : str | Path
+            Path to the configuration file.
+        is_sandbox : bool, optional
+            Whether the configuration is a sandbox configuration, by default False
+
+        Returns
+        -------
+        AuthConfigurationManager
+            A new instance of the AuthConfigurationManager.
+        """
+        return super().from_file(
+            path, conf_class=AuthConfiguration, is_sandbox=is_sandbox
+        )
 
     def get_config_template(self) -> str:
         """
@@ -229,5 +260,23 @@ class TestingConfigurationManager(ConfigurationManager):
         super().__init__(conf_class=TestConfiguration, name=name)
 
     @classmethod
-    def from_file(cls, path):
-        return super().from_file(path, conf_class=TestConfiguration)
+    def from_file(cls, path: Path | str, is_sandbox: bool = False) -> Self:
+        """
+        Create a new instance of the TestingConfigurationManager from a
+        configuration file.
+
+        Parameters
+        ----------
+        path : str | Path
+            Path to the configuration file.
+        is_sandbox : bool, optional
+            Whether the configuration is a sandbox configuration, by default False
+
+        Returns
+        -------
+        TestingConfigurationManager
+            A new instance of the TestingConfigurationManager.
+        """
+        return super().from_file(
+            path, conf_class=TestConfiguration, is_sandbox=is_sandbox
+        )

vantage6/cli/context/__init__.py

@@ -13,6 +13,7 @@ from colorama import Fore, Style
 from vantage6.common import error
 from vantage6.common.globals import InstanceType
 
+from vantage6.cli.common.utils import extract_name_and_is_sandbox
 from vantage6.cli.context.algorithm_store import AlgorithmStoreContext
 from vantage6.cli.context.auth import AuthContext
 from vantage6.cli.context.node import NodeContext
@@ -21,7 +22,7 @@ from vantage6.cli.context.server import ServerContext
 
 def select_context_class(
     type_: InstanceType,
-) -> ServerContext | NodeContext | AlgorithmStoreContext:
+) -> ServerContext | NodeContext | AlgorithmStoreContext | AuthContext:
     """
     Select the context class based on the type of instance.
 
@@ -32,7 +33,7 @@ def select_context_class(
 
     Returns
     -------
-    ServerContext | NodeContext | AlgorithmStoreContext
+    ServerContext | NodeContext | AlgorithmStoreContext | AuthContext
         Specialized subclass of AppContext for the given instance type
 
     Raises
@@ -53,7 +54,7 @@ def select_context_class(
 
 
 def get_context(
-    type_: InstanceType, name: str, system_folders: bool
+    type_: InstanceType, name: str, system_folders: bool, is_sandbox: bool = False
 ) -> ServerContext | NodeContext | AlgorithmStoreContext:
     """
     Load the server context from the configuration file.
@@ -66,14 +67,18 @@ def get_context(
         Name of the instance
     system_folders : bool
         Wether to use system folders or if False, the user folders
+    is_sandbox : bool
+        Whether the configuration is a sandbox configuration, by default False
 
     Returns
     -------
     AppContext
         Specialized subclass context of AppContext for the given instance type
     """
+    name, is_sandbox = extract_name_and_is_sandbox(name, is_sandbox)
+
     ctx_class = select_context_class(type_)
-    if not ctx_class.config_exists(name, system_folders):
+    if not ctx_class.config_exists(name, system_folders, is_sandbox=is_sandbox):
         scope = "system" if system_folders else "user"
         error(
             f"Configuration {Fore.RED}{name}{Style.RESET_ALL} does not "
@@ -86,6 +91,6 @@ def get_context(
     ctx_class.LOGGING_ENABLED = False
 
     # create server context, and initialize db
-    ctx = ctx_class(name, system_folders=system_folders)
+    ctx = ctx_class(name, system_folders=system_folders, is_sandbox=is_sandbox)
 
     return ctx

vantage6/cli/context/algorithm_store.py

@@ -26,11 +26,14 @@ class AlgorithmStoreContext(BaseServerContext):
 
     INST_CONFIG_MANAGER = AlgorithmStoreConfigurationManager
 
-    def __init__(self, instance_name: str, system_folders: bool = S_FOL):
+    def __init__(
+        self, instance_name: str, system_folders: bool = S_FOL, is_sandbox: bool = False
+    ):
         super().__init__(
             InstanceType.ALGORITHM_STORE,
             instance_name,
             system_folders=system_folders,
+            is_sandbox=is_sandbox,
         )
         self.log.info("vantage6 version '%s'", __version__)
 
@@ -88,7 +91,9 @@ class AlgorithmStoreContext(BaseServerContext):
         )
 
     @classmethod
-    def config_exists(cls, instance_name: str, system_folders: bool = S_FOL) -> bool:
+    def config_exists(
+        cls, instance_name: str, system_folders: bool = S_FOL, is_sandbox: bool = False
+    ) -> bool:
         """
         Check if a configuration file exists.
 
@@ -99,19 +104,20 @@ class AlgorithmStoreContext(BaseServerContext):
             of the configuration file.
         system_folders : bool, optional
             System wide or user configuration, by default S_FOL
-
+        is_sandbox : bool, optional
+            Whether the configuration is a sandbox configuration, by default False
         Returns
         -------
         bool
             Whether the configuration file exists or not
         """
-        return super().config_exists(
-            InstanceType.ALGORITHM_STORE, instance_name, system_folders
+        return super().base_config_exists(
+            InstanceType.ALGORITHM_STORE, instance_name, system_folders, is_sandbox
         )
 
     @classmethod
     def available_configurations(
-        cls, system_folders: bool = S_FOL
+        cls, system_folders: bool = S_FOL, is_sandbox: bool = False
     ) -> tuple[list, list]:
         """
         Find all available server configurations in the default folders.
@@ -128,5 +134,5 @@ class AlgorithmStoreContext(BaseServerContext):
             list contains invalid configuration files.
         """
         return super().available_configurations(
-            InstanceType.ALGORITHM_STORE, system_folders
+            InstanceType.ALGORITHM_STORE, system_folders, is_sandbox
         )

vantage6/cli/context/auth.py

@@ -19,6 +19,8 @@ class AuthContext(AppContext):
         of the configuration file.
     system_folders : bool, optional
         System wide or user configuration, by default S_FOL
+    is_sandbox : bool, optional
+        Whether the configuration is a sandbox configuration, by default False
     """
 
     # The auth configuration manager is aware of the structure of the auth
@@ -29,11 +31,13 @@ class AuthContext(AppContext):
         self,
         instance_name: str,
         system_folders: bool = S_FOL,
+        is_sandbox: bool = False,
     ):
         super().__init__(
             InstanceType.AUTH,
             instance_name,
             system_folders=system_folders,
+            is_sandbox=is_sandbox,
         )
         self.log.info("vantage6 version '%s'", __version__)
 
@@ -65,7 +69,12 @@ class AuthContext(AppContext):
         )
 
     @classmethod
-    def config_exists(cls, instance_name: str, system_folders: bool = S_FOL) -> bool:
+    def config_exists(
+        cls,
+        instance_name: str,
+        system_folders: bool = S_FOL,
+        is_sandbox: bool = False,
+    ) -> bool:
         """
         Check if a configuration file exists.
 
@@ -76,19 +85,24 @@ class AuthContext(AppContext):
             of the configuration file.
         system_folders : bool, optional
             System wide or user configuration, by default S_FOL
+        is_sandbox : bool, optional
+            Whether the configuration is a sandbox configuration, by default False
 
         Returns
         -------
         bool
             Whether the configuration file exists or not
         """
-        return super().config_exists(
-            InstanceType.AUTH, instance_name, system_folders=system_folders
+        return super().base_config_exists(
+            InstanceType.AUTH,
+            instance_name,
+            system_folders=system_folders,
+            is_sandbox=is_sandbox,
         )
 
     @classmethod
     def available_configurations(
-        cls, system_folders: bool = S_FOL
+        cls, system_folders: bool = S_FOL, is_sandbox: bool = False
     ) -> tuple[list, list]:
         """
         Find all available auth configurations in the default folders.
@@ -97,6 +111,8 @@ class AuthContext(AppContext):
         ----------
         system_folders : bool, optional
             System wide or user configuration, by default S_FOL
+        is_sandbox : bool, optional
+            Whether the configuration is a sandbox configuration, by default False
 
         Returns
         -------
@@ -104,4 +120,6 @@ class AuthContext(AppContext):
             The first list contains validated configuration files, the second
             list contains invalid configuration files.
         """
-        return super().available_configurations(InstanceType.AUTH, system_folders)
+        return super().available_configurations(
+            InstanceType.AUTH, system_folders, is_sandbox
+        )

vantage6/cli/context/node.py

@@ -27,6 +27,8 @@ class NodeContext(AppContext):
         _description_, by default None
     in_container : bool, optional
         Whether the application is running inside a container, by default False
+    is_sandbox : bool, optional
+        Whether the configuration is a sandbox configuration, by default False
     """
 
     # The server configuration manager is aware of the structure of the server
@@ -41,6 +43,7 @@ class NodeContext(AppContext):
         print_log_header: bool = True,
         logger_prefix: str = "",
         in_container: bool = False,
+        is_sandbox: bool = False,
     ):
         super().__init__(
             InstanceType.NODE,
@@ -50,6 +53,7 @@ class NodeContext(AppContext):
             print_log_header=print_log_header,
             logger_prefix=logger_prefix,
             in_container=in_container,
+            is_sandbox=is_sandbox,
         )
         if print_log_header:
             self.log.info("vantage6 version '%s'", __version__)
@@ -57,7 +61,7 @@ class NodeContext(AppContext):
 
     @classmethod
     def from_external_config_file(
-        cls, path: str, system_folders: bool = N_FOL
+        cls, path: str, system_folders: bool = N_FOL, is_sandbox: bool = False
     ) -> NodeContext:
         """
         Create a node context from an external configuration file. External
@@ -77,11 +81,16 @@ class NodeContext(AppContext):
             Node context object
         """
         return super().from_external_config_file(
-            Path(path).resolve(), InstanceType.NODE, system_folders
+            Path(path).resolve(),
+            InstanceType.NODE,
+            system_folders,
+            is_sandbox=is_sandbox,
         )
 
     @classmethod
-    def config_exists(cls, instance_name: str, system_folders: bool = N_FOL) -> bool:
+    def config_exists(
+        cls, instance_name: str, system_folders: bool = N_FOL, is_sandbox: bool = False
+    ) -> bool:
         """
         Check if a configuration file exists.
 
@@ -92,19 +101,23 @@ class NodeContext(AppContext):
             of the configuration file.
         system_folders : bool, optional
             System wide or user configuration, by default N_FOL
-
+        is_sandbox : bool, optional
+            Whether the configuration is a sandbox configuration, by default False
         Returns
         -------
         bool
             Whether the configuration file exists or not
         """
-        return super().config_exists(
-            InstanceType.NODE, instance_name, system_folders=system_folders
+        return super().base_config_exists(
+            InstanceType.NODE,
+            instance_name,
+            system_folders=system_folders,
+            is_sandbox=is_sandbox,
         )
 
     @classmethod
     def available_configurations(
-        cls, system_folders: bool = N_FOL
+        cls, system_folders: bool = N_FOL, is_sandbox: bool = False
     ) -> tuple[list, list]:
         """
         Find all available server configurations in the default folders.
@@ -113,6 +126,8 @@ class NodeContext(AppContext):
         ----------
         system_folders : bool, optional
             System wide or user configuration, by default N_FOL
+        is_sandbox : bool, optional
+            Whether the configuration is a sandbox configuration, by default False
 
         Returns
         -------
@@ -120,7 +135,9 @@ class NodeContext(AppContext):
             The first list contains validated configuration files, the second
             list contains invalid configuration files.
         """
-        return super().available_configurations(InstanceType.NODE, system_folders)
+        return super().available_configurations(
+            InstanceType.NODE, system_folders, is_sandbox
+        )
 
     @staticmethod
     def type_data_folder(system_folders: bool = N_FOL) -> Path: