vantage6 4.2.1__py3-none-any.whl → 4.3.0b3__py3-none-any.whl

vantage6/cli/dev/create.py

@@ -5,11 +5,12 @@ import click
 from jinja2 import Environment, FileSystemLoader
 from colorama import Fore, Style
 
-from vantage6.common.globals import APPNAME
+from vantage6.common.globals import APPNAME, InstanceType
 from vantage6.common import info, error, generate_apikey
 
 from vantage6.cli.globals import PACKAGE_FOLDER
-from vantage6.cli.context import ServerContext, NodeContext
+from vantage6.cli.context.server import ServerContext
+from vantage6.cli.context.node import NodeContext
 from vantage6.cli.server.common import get_server_context
 from vantage6.cli.server.import_ import cli_server_import
 from vantage6.cli.utils import prompt_config_name
@@ -30,14 +31,14 @@ def create_dummy_data(node_name: str, dev_folder: Path) -> Path:
     Path
         Directory the data is saved in.
     """
-    header = ['name', 'mask', 'weapon', 'age']
+    header = ["name", "mask", "weapon", "age"]
     data = [
-        ['Raphael', 'red', 'sai', 44],
-        ['Donatello', 'purple', 'bo staff', 60],
+        ["Raphael", "red", "sai", 44],
+        ["Donatello", "purple", "bo staff", 60],
     ]
 
     data_file = dev_folder / f"df_{node_name}.csv"
-    with open(data_file, 'w', encoding='UTF8', newline='') as f:
+    with open(data_file, "w", encoding="UTF8", newline="") as f:
         writer = csv.writer(f)
 
         # write the header
@@ -49,13 +50,16 @@ def create_dummy_data(node_name: str, dev_folder: Path) -> Path:
 
         f.close()
 
-    info(f"Spawned dataset for {Fore.GREEN}{node_name}{Style.RESET_ALL}, "
-         f"writing to {Fore.GREEN}{data_file}{Style.RESET_ALL}")
+    info(
+        f"Spawned dataset for {Fore.GREEN}{node_name}{Style.RESET_ALL}, "
+        f"writing to {Fore.GREEN}{data_file}{Style.RESET_ALL}"
+    )
     return data_file
 
 
-def create_node_config_file(server_url: str, port: int, config: dict,
-                            server_name: str) -> None:
+def create_node_config_file(
+    server_url: str, port: int, config: dict, server_name: str
+) -> None:
     """Create a node configuration file (YAML).
 
     Creates a node configuration for a simulated organization. Organization ID
@@ -76,47 +80,50 @@ def create_node_config_file(server_url: str, port: int, config: dict,
     """
     environment = Environment(
         loader=FileSystemLoader(PACKAGE_FOLDER / APPNAME / "cli" / "template"),
-        trim_blocks=True, lstrip_blocks=True, autoescape=True)
+        trim_blocks=True,
+        lstrip_blocks=True,
+        autoescape=True,
+    )
     template = environment.get_template("node_config.j2")
 
     # TODO: make this name specific to the server it connects
-    node_name = config['node_name']
-    folders = NodeContext.instance_folders('node', node_name, False)
-    path_to_dev_dir = Path(folders['dev'] / server_name)
+    node_name = config["node_name"]
+    folders = NodeContext.instance_folders("node", node_name, False)
+    path_to_dev_dir = Path(folders["dev"] / server_name)
     path_to_dev_dir.mkdir(parents=True, exist_ok=True)
     dummy_datafile = create_dummy_data(node_name, path_to_dev_dir)
 
-    path_to_data_dir = Path(folders['data'])
+    path_to_data_dir = Path(folders["data"])
     path_to_data_dir.mkdir(parents=True, exist_ok=True)
-    full_path = Path(folders['config'] / f'{node_name}.yaml')
+    full_path = Path(folders["config"] / f"{node_name}.yaml")
 
     if full_path.exists():
         error(f"Node configuration file already exists: {full_path}")
         exit(1)
 
-    node_config = template.render({
-        "api_key": config['api_key'],
-        "databases": {
-            "default": dummy_datafile
-        },
-        "logging": {
-            "file": f'{node_name}.log'
-        },
-        "port": port,
-        "server_url": server_url,
-        "task_dir": str(path_to_data_dir),
-        "user_provided_config": config['user_defined_config']
-    })
+    node_config = template.render(
+        {
+            "api_key": config["api_key"],
+            "databases": {"default": dummy_datafile},
+            "logging": {"file": f"{node_name}.log"},
+            "port": port,
+            "server_url": server_url,
+            "task_dir": str(path_to_data_dir),
+            "user_provided_config": config["user_defined_config"],
+        }
+    )
 
     try:
-        with open(full_path, 'x') as f:
+        with open(full_path, "x") as f:
             f.write(node_config)
     except Exception as e:
         error(f"Could not write node configuration file: {e}")
         exit(1)
 
-    info(f"Spawned node for organization {Fore.GREEN}{config['org_id']}"
-         f"{Style.RESET_ALL}")
+    info(
+        f"Spawned node for organization {Fore.GREEN}{config['org_id']}"
+        f"{Style.RESET_ALL}"
+    )
 
 
 def _read_extra_config_file(extra_config_file: Path | None) -> str:
@@ -135,14 +142,17 @@ def _read_extra_config_file(extra_config_file: Path | None) -> str:
     if extra_config_file:
         # read the YAML file as string, so it can be appended to the
         # configuration easily
-        with open(extra_config_file, 'r', encoding='utf-8') as f:
+        with open(extra_config_file, "r", encoding="utf-8") as f:
             return f.read()
-    return ''
+    return ""
 
 
 def generate_node_configs(
-    num_nodes: int, server_url: str, port: int, server_name: str,
-    extra_node_config: Path | None
+    num_nodes: int,
+    server_url: str,
+    port: int,
+    server_name: str,
+    extra_node_config: Path | None,
 ) -> list[dict]:
     """Generates ``num_nodes`` node configuration files.
 
@@ -168,10 +178,10 @@ def generate_node_configs(
     extra_config = _read_extra_config_file(extra_node_config)
     for i in range(num_nodes):
         config = {
-            'org_id': i + 1,
-            'api_key': generate_apikey(),
-            'node_name': f"{server_name}_node_{i + 1}",
-            "user_defined_config": extra_config
+            "org_id": i + 1,
+            "api_key": generate_apikey(),
+            "node_name": f"{server_name}_node_{i + 1}",
+            "user_defined_config": extra_config,
         }
         create_node_config_file(server_url, port, config, server_name)
         configs.append(config)
@@ -179,8 +189,7 @@ def generate_node_configs(
     return configs
 
 
-def create_vserver_import_config(node_configs: list[dict], server_name: str) \
-        -> Path:
+def create_vserver_import_config(node_configs: list[dict], server_name: str) -> Path:
     """Create server configuration import file (YAML).
 
     Utilized by the ``v6 server import`` command.
@@ -200,38 +209,47 @@ def create_vserver_import_config(node_configs: list[dict], server_name: str) \
     """
     environment = Environment(
         loader=FileSystemLoader(PACKAGE_FOLDER / APPNAME / "cli" / "template"),
-        trim_blocks=True, lstrip_blocks=True, autoescape=True)
+        trim_blocks=True,
+        lstrip_blocks=True,
+        autoescape=True,
+    )
     template = environment.get_template("server_import_config.j2")
 
     organizations = []
-    collaboration = {'name': 'demo', 'participants': []}
+    collaboration = {"name": "demo", "participants": []}
     for config in node_configs:
-        org_id = config['org_id']
-        org_data = {'name': f"org_{org_id}"}
+        org_id = config["org_id"]
+        org_data = {"name": f"org_{org_id}"}
 
         organizations.append(org_data)
-        collaboration['participants'].append({'name': f"org_{org_id}",
-                                              'api_key': config['api_key']})
-    organizations[0]['make_admin'] = True
-    info(f"Organization {Fore.GREEN}{node_configs[0]['org_id']}"
-         f"{Style.RESET_ALL} is the admin")
+        collaboration["participants"].append(
+            {"name": f"org_{org_id}", "api_key": config["api_key"]}
+        )
+    organizations[0]["make_admin"] = True
+    info(
+        f"Organization {Fore.GREEN}{node_configs[0]['org_id']}"
+        f"{Style.RESET_ALL} is the admin"
+    )
 
-    server_import_config = template.render(organizations=organizations,
-                                           collaboration=collaboration)
-    folders = ServerContext.instance_folders("server", server_name, False)
+    server_import_config = template.render(
+        organizations=organizations, collaboration=collaboration
+    )
+    folders = ServerContext.instance_folders(InstanceType.SERVER, server_name, False)
 
-    demo_dir = Path(folders['dev'])
+    demo_dir = Path(folders["dev"])
     demo_dir.mkdir(parents=True, exist_ok=True)
-    full_path = demo_dir / f'{server_name}.yaml'
+    full_path = demo_dir / f"{server_name}.yaml"
     if full_path.exists():
         error(f"Server configuration file already exists: {full_path}")
         exit(1)
 
     try:
-        with open(full_path, 'x') as f:
+        with open(full_path, "x") as f:
             f.write(server_import_config)
-            info("Server import configuration ready, writing to "
-                 f"{Fore.GREEN}{full_path}{Style.RESET_ALL}")
+            info(
+                "Server import configuration ready, writing to "
+                f"{Fore.GREEN}{full_path}{Style.RESET_ALL}"
+            )
     except Exception as e:
         error(f"Could not write server import configuration file: {e}")
         exit(1)
@@ -239,9 +257,7 @@ def create_vserver_import_config(node_configs: list[dict], server_name: str) \
     return full_path
 
 
-def create_vserver_config(
-    server_name: str, port: int, extra_config_file: Path
-) -> Path:
+def create_vserver_config(server_name: str, port: int, extra_config_file: Path) -> Path:
     """Creates server configuration file (YAML).
 
     Parameters
@@ -260,32 +276,35 @@ def create_vserver_config(
     """
     environment = Environment(
         loader=FileSystemLoader(PACKAGE_FOLDER / APPNAME / "cli" / "template"),
-        trim_blocks=True, lstrip_blocks=True, autoescape=True)
+        trim_blocks=True,
+        lstrip_blocks=True,
+        autoescape=True,
+    )
 
     extra_config = _read_extra_config_file(extra_config_file)
 
     template = environment.get_template("server_config.j2")
     server_config = template.render(
-        port=port,
-        jwt_secret_key=generate_apikey(),
-        user_provided_config=extra_config
+        port=port, jwt_secret_key=generate_apikey(), user_provided_config=extra_config
     )
     folders = ServerContext.instance_folders(
-        instance_type='server', instance_name=server_name,
-        system_folders=True)
+        instance_type="server", instance_name=server_name, system_folders=True
+    )
 
-    config_dir = Path(folders['config'] / server_name)
+    config_dir = Path(folders["config"] / server_name)
     config_dir.mkdir(parents=True, exist_ok=True)
-    full_path = folders["config"] / f'{server_name}.yaml'
+    full_path = folders["config"] / f"{server_name}.yaml"
     if full_path.exists():
         error(f"Server configuration file already exists: {full_path}")
         exit(1)
 
     try:
-        with open(full_path, 'x') as f:
+        with open(full_path, "x") as f:
             f.write(server_config)
-            info("Server configuration read, writing to "
-                 f"{Fore.GREEN}{full_path}{Style.RESET_ALL}")
+            info(
+                "Server configuration read, writing to "
+                f"{Fore.GREEN}{full_path}{Style.RESET_ALL}"
+            )
     except Exception as e:
         error(f"Could not write server configuration file: {e}")
         exit(1)
@@ -294,8 +313,12 @@ def create_vserver_config(
 
 
 def demo_network(
-    num_nodes: int, server_url: str, server_port: int, server_name: str,
-    extra_server_config: Path, extra_node_config: Path
+    num_nodes: int,
+    server_url: str,
+    server_port: int,
+    server_name: str,
+    extra_server_config: Path,
+    extra_node_config: Path,
 ) -> tuple[list[dict], Path, Path]:
     """Generates the demo network.
 
@@ -319,40 +342,71 @@ def demo_network(
     tuple[list[dict], Path, Path]
         Tuple containing node, server import and server configurations.
     """
-    node_configs = generate_node_configs(num_nodes, server_url, server_port,
-                                         server_name, extra_node_config)
-    server_import_config = create_vserver_import_config(node_configs,
-                                                        server_name)
-    server_config = create_vserver_config(server_name, server_port,
-                                          extra_server_config)
+    node_configs = generate_node_configs(
+        num_nodes, server_url, server_port, server_name, extra_node_config
+    )
+    server_import_config = create_vserver_import_config(node_configs, server_name)
+    server_config = create_vserver_config(server_name, server_port, extra_server_config)
     return (node_configs, server_import_config, server_config)
 
 
 @click.command()
-@click.option('-n', '--name', default=None, type=str,
-              help="Name for your development setup")
-@click.option('--num-nodes', type=int, default=3,
-              help='Generate this number of nodes in the development network')
-@click.option('--server-url', type=str, default='http://host.docker.internal',
-              help='Server URL to point to. If you are using Docker Desktop, '
-              'the default http://host.docker.internal should not be changed.')
-@click.option('-p', '--server-port', type=int, default=5000,
-              help='Port to run the server on. Default is 5000.')
-@click.option('-i', '--image', type=str, default=None,
-              help='Server docker image to use when setting up resources for '
-              'the development server')
-@click.option('--extra-server-config', type=click.Path(exists=True),
-              default=None, help='YAML File with additional server '
-              'configuration. This will be appended to the server '
-              'configuration file')
-@click.option('--extra-node-config', type=click.Path('rb'), default=None,
-              help='YAML File with additional node configuration. This will be'
-              ' appended to each of the node configuration files')
+@click.option(
+    "-n", "--name", default=None, type=str, help="Name for your development setup"
+)
+@click.option(
+    "--num-nodes",
+    type=int,
+    default=3,
+    help="Generate this number of nodes in the development network",
+)
+@click.option(
+    "--server-url",
+    type=str,
+    default="http://host.docker.internal",
+    help="Server URL to point to. If you are using Docker Desktop, "
+    "the default http://host.docker.internal should not be changed.",
+)
+@click.option(
+    "-p",
+    "--server-port",
+    type=int,
+    default=5000,
+    help="Port to run the server on. Default is 5000.",
+)
+@click.option(
+    "-i",
+    "--image",
+    type=str,
+    default=None,
+    help="Server docker image to use when setting up resources for "
+    "the development server",
+)
+@click.option(
+    "--extra-server-config",
+    type=click.Path(exists=True),
+    default=None,
+    help="YAML File with additional server "
+    "configuration. This will be appended to the server "
+    "configuration file",
+)
+@click.option(
+    "--extra-node-config",
+    type=click.Path("rb"),
+    default=None,
+    help="YAML File with additional node configuration. This will be"
+    " appended to each of the node configuration files",
+)
 @click.pass_context
 def create_demo_network(
-    click_ctx: click.Context, name: str, num_nodes: int, server_url: str,
-    server_port: int, image: str = None, extra_server_config: Path = None,
-    extra_node_config: Path = None
+    click_ctx: click.Context,
+    name: str,
+    num_nodes: int,
+    server_url: str,
+    server_port: int,
+    image: str = None,
+    extra_server_config: Path = None,
+    extra_node_config: Path = None,
 ) -> dict:
     """Creates a demo network.
 
@@ -364,24 +418,37 @@ def create_demo_network(
     server_name = prompt_config_name(name)
     if not ServerContext.config_exists(server_name):
         demo = demo_network(
-            num_nodes, server_url, server_port, server_name,
-            extra_server_config, extra_node_config
+            num_nodes,
+            server_url,
+            server_port,
+            server_name,
+            extra_server_config,
+            extra_node_config,
+        )
+        info(
+            f"Created {Fore.GREEN}{len(demo[0])}{Style.RESET_ALL} node "
+            f"configuration(s), attaching them to {Fore.GREEN}{server_name}"
+            f"{Style.RESET_ALL}."
         )
-        info(f"Created {Fore.GREEN}{len(demo[0])}{Style.RESET_ALL} node "
-             f"configuration(s), attaching them to {Fore.GREEN}{server_name}"
-             f"{Style.RESET_ALL}.")
     else:
-        error(f"Configuration {Fore.RED}{server_name}{Style.RESET_ALL} "
-              "already exists!")
+        error(
+            f"Configuration {Fore.RED}{server_name}{Style.RESET_ALL} " "already exists!"
+        )
         exit(1)
     (node_config, server_import_config, server_config) = demo
     ctx = get_server_context(server_name, True)
     click_ctx.invoke(
-        cli_server_import, ctx=ctx, file=server_import_config, drop_all=False,
-        image=image, mount_src='', keep=False, wait=True
+        cli_server_import,
+        ctx=ctx,
+        file=server_import_config,
+        drop_all=False,
+        image=image,
+        mount_src="",
+        keep=False,
+        wait=True,
     )
     return {
         "node_configs": node_config,
         "server_import_config": server_import_config,
-        "server_config": server_config
+        "server_config": server_config,
     }

vantage6/cli/dev/remove.py

@@ -6,19 +6,19 @@ from pathlib import Path
 import click
 
 from vantage6.common import info
-from vantage6.cli.context import ServerContext, NodeContext
+from vantage6.cli.context.server import ServerContext
+from vantage6.cli.context.node import NodeContext
 from vantage6.cli.server.common import click_insert_context
 from vantage6.cli.server.remove import cli_server_remove
 from vantage6.cli.utils import remove_file
+from vantage6.common.globals import InstanceType
 
 
 @click.command()
 @click_insert_context
 @click.pass_context
-def remove_demo_network(
-    click_ctx: click.Context, ctx: ServerContext
-) -> None:
-    """ Remove all related demo network files and folders.
+def remove_demo_network(click_ctx: click.Context, ctx: ServerContext) -> None:
+    """Remove all related demo network files and folders.
 
     Select a server configuration to remove that server and the nodes attached
     to it.
@@ -31,32 +31,33 @@ def remove_demo_network(
 
     # removing the server import config
     info("Deleting demo import config file")
-    server_configs = ServerContext.instance_folders("server", ctx.name,
-                                                    system_folders=False)
-    import_config_to_del = Path(server_configs['dev']) / f"{ctx.name}.yaml"
-    remove_file(import_config_to_del, 'import_configuration')
+    server_configs = ServerContext.instance_folders(
+        InstanceType.SERVER, ctx.name, system_folders=False
+    )
+    import_config_to_del = Path(server_configs["dev"]) / f"{ctx.name}.yaml"
+    remove_file(import_config_to_del, "import_configuration")
 
     # also remove the server folder
-    server_configs = ServerContext.instance_folders("server", ctx.name,
-                                                    system_folders=True)
-    server_folder = server_configs['data']
+    server_configs = ServerContext.instance_folders(
+        InstanceType.SERVER, ctx.name, system_folders=True
+    )
+    server_folder = server_configs["data"]
     if server_folder.is_dir():
         rmtree(server_folder)
 
     # remove the nodes
     configs, _ = NodeContext.available_configurations(system_folders=False)
     node_names = [
-        config.name for config in configs if f'{ctx.name}_node_' in config.name
+        config.name for config in configs if f"{ctx.name}_node_" in config.name
     ]
     for name in node_names:
         node_ctx = NodeContext(name, False)
-        for handler in itertools.chain(node_ctx.log.handlers,
-                                       node_ctx.log.root.handlers):
+        for handler in itertools.chain(
+            node_ctx.log.handlers, node_ctx.log.root.handlers
+        ):
             handler.close()
-        subprocess.run(
-            ["v6", "node", "remove", "-n", name, "--user", "--force"]
-        )
+        subprocess.run(["v6", "node", "remove", "-n", name, "--user", "--force"])
 
     # remove data files attached to the network
-    data_dirs_nodes = NodeContext.instance_folders('node', '', False)['dev']
+    data_dirs_nodes = NodeContext.instance_folders("node", "", False)["dev"]
     rmtree(Path(data_dirs_nodes / ctx.name))

vantage6/cli/dev/start.py

@@ -1,21 +1,21 @@
 import subprocess
 import click
 
-from vantage6.cli.context import ServerContext, NodeContext
+from vantage6.cli.context.server import ServerContext
+from vantage6.cli.context.node import NodeContext
 from vantage6.cli.server.common import click_insert_context
 from vantage6.cli.server.start import cli_server_start
 
 
 @click.command()
 @click_insert_context
-@click.option('--server-image', type=str, default=None,
-              help='Server Docker image to use')
-@click.option('--node-image', type=str, default=None,
-              help='Node Docker image to use')
+@click.option(
+    "--server-image", type=str, default=None, help="Server Docker image to use"
+)
+@click.option("--node-image", type=str, default=None, help="Node Docker image to use")
 @click.pass_context
 def start_demo_network(
-    click_ctx: click.Context, ctx: ServerContext, server_image: str,
-    node_image: str
+    click_ctx: click.Context, ctx: ServerContext, server_image: str, node_image: str
 ) -> None:
     """Starts running a demo-network.
 
@@ -36,14 +36,14 @@ def start_demo_network(
         start_rabbitmq=False,
         rabbitmq_image=None,
         keep=True,
-        mount_src='',
-        attach=False
+        mount_src="",
+        attach=False,
     )
 
     # run all nodes that belong to this server
     configs, _ = NodeContext.available_configurations(system_folders=False)
     node_names = [
-        config.name for config in configs if f'{ctx.name}_node_' in config.name
+        config.name for config in configs if f"{ctx.name}_node_" in config.name
     ]
     for name in node_names:
         cmd = ["v6", "node", "start", "--name", name]

vantage6/cli/dev/stop.py

@@ -1,6 +1,7 @@
 import click
 
-from vantage6.cli.context import ServerContext, NodeContext
+from vantage6.cli.context.server import ServerContext
+from vantage6.cli.context.node import NodeContext
 from vantage6.cli.server.common import click_insert_context
 from vantage6.cli.server.stop import cli_server_stop
 from vantage6.cli.node.stop import cli_node_stop
@@ -10,7 +11,7 @@ from vantage6.cli.node.stop import cli_node_stop
 @click_insert_context
 @click.pass_context
 def stop_demo_network(click_ctx: click.Context, ctx: ServerContext) -> None:
-    """ Stops a demo network's server and nodes.
+    """Stops a demo network's server and nodes.
 
     Select a server configuration to stop that server and the nodes attached
     to it.
@@ -23,8 +24,9 @@ def stop_demo_network(click_ctx: click.Context, ctx: ServerContext) -> None:
     # stop the nodes
     configs, _ = NodeContext.available_configurations(False)
     node_names = [
-        config.name for config in configs if f'{ctx.name}_node_' in config.name
+        config.name for config in configs if f"{ctx.name}_node_" in config.name
     ]
     for name in node_names:
-        click_ctx.invoke(cli_node_stop, name=name, system_folders=False,
-                         all_nodes=False, force=False)
+        click_ctx.invoke(
+            cli_node_stop, name=name, system_folders=False, all_nodes=False, force=False
+        )

vantage6/cli/globals.py

@@ -1,6 +1,7 @@
 """
 This module contains global variables that are used throughout the CLI.
 """
+from enum import Enum
 from pathlib import Path
 from vantage6.common.globals import APPNAME
 
@@ -39,3 +40,26 @@ ALGORITHM_TEMPLATE_REPO = "gh:vantage6/v6-algorithm-template.git"
 
 # image to use for diagnostics in `v6 test` commands
 DIAGNOSTICS_IMAGE = "harbor2.vantage6.ai/algorithms/diagnostic"
+
+
+class ServerType(str, Enum):
+    """Enum containing server types"""
+
+    V6SERVER = "server"
+    ALGORITHM_STORE = "algorithm-store"
+
+
+class ServerGlobals(str, Enum):
+    """Enum containing server environment variables"""
+
+    DB_URI_ENV_VAR = "VANTAGE6_DB_URI"
+    CONFIG_NAME_ENV_VAR = "VANTAGE6_CONFIG_NAME"
+    PORT = "5000"
+
+
+class AlgoStoreGlobals(str, Enum):
+    """Enum containing algorithm store environment variables"""
+
+    DB_URI_ENV_VAR = "VANTAGE6_ALGO_STORE_DB_URI"
+    CONFIG_NAME_ENV_VAR = "VANTAGE6_ALGO_STORE_CONFIG_NAME"
+    PORT = "5002"  # 5001 is the default UI port