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

vantage6/cli/context/algorithm_store.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from vantage6.common.globals import APPNAME, InstanceType
+from vantage6.cli.configuration_manager import ServerConfigurationManager
+from vantage6.cli.globals import (
+    DEFAULT_SERVER_SYSTEM_FOLDERS as S_FOL,
+    ServerType,
+    AlgoStoreGlobals,
+)
+from vantage6.cli._version import __version__
+from vantage6.cli.context.base_server import BaseServerContext
+
+
+class AlgorithmStoreContext(BaseServerContext):
+    """
+    A context class for the algorithm store server.
+
+    Parameters
+    ----------
+    instance_name : str
+        Name of the configuration instance, corresponds to the filename
+        of the configuration file.
+    system_folders : bool, optional
+        System wide or user configuration, by default S_FOL
+    """
+
+    INST_CONFIG_MANAGER = ServerConfigurationManager
+
+    def __init__(self, instance_name: str, system_folders: bool = S_FOL):
+        super().__init__(
+            InstanceType.ALGORITHM_STORE, instance_name, system_folders=system_folders
+        )
+        self.log.info("vantage6 version '%s'", __version__)
+
+    def get_database_uri(self) -> str:
+        """
+        Obtain the database uri from the environment or the configuration. The
+        `VANTAGE6_DB_URI` environment variable is used by the Docker container,
+        but can also be set by the user.
+
+        Returns
+        -------
+        str
+            string representation of the database uri
+        """
+        return super().get_database_uri(AlgoStoreGlobals.DB_URI_ENV_VAR)
+
+    @property
+    def docker_container_name(self) -> str:
+        """
+        Name of the docker container that the server is running in.
+
+        Returns
+        -------
+        str
+            Server's docker container name
+        """
+        return f"{APPNAME}-{self.name}-{self.scope}-{ServerType.ALGORITHM_STORE}"
+
+    @classmethod
+    def from_external_config_file(
+        cls, path: str, system_folders: bool = S_FOL
+    ) -> AlgorithmStoreContext:
+        """
+        Create a server context from an external configuration file. External
+        means that the configuration file is not located in the default folders
+        but its location is specified by the user.
+
+        Parameters
+        ----------
+        path : str
+            Path of the configuration file
+        system_folders : bool, optional
+            System wide or user configuration, by default S_FOL
+
+        Returns
+        -------
+        AlgorithmStoreContext
+            Server context object
+        """
+        return super().from_external_config_file(
+            path,
+            ServerType.ALGORITHM_STORE,
+            AlgoStoreGlobals.CONFIG_NAME_ENV_VAR,
+            system_folders,
+        )
+
+    @classmethod
+    def config_exists(cls, instance_name: str, system_folders: bool = S_FOL) -> bool:
+        """
+        Check if a configuration file exists.
+
+        Parameters
+        ----------
+        instance_name : str
+            Name of the configuration instance, corresponds to the filename
+            of the configuration file.
+        system_folders : bool, optional
+            System wide or user configuration, by default S_FOL
+
+        Returns
+        -------
+        bool
+            Whether the configuration file exists or not
+        """
+        return super().config_exists(
+            InstanceType.ALGORITHM_STORE, instance_name, system_folders
+        )
+
+    @classmethod
+    def available_configurations(
+        cls, system_folders: bool = S_FOL
+    ) -> tuple[list, list]:
+        """
+        Find all available server configurations in the default folders.
+
+        Parameters
+        ----------
+        system_folders : bool, optional
+            System wide or user configuration, by default S_FOL
+
+        Returns
+        -------
+        tuple[list, list]
+            The first list contains validated configuration files, the second
+            list contains invalid configuration files.
+        """
+        return super().available_configurations(
+            InstanceType.ALGORITHM_STORE, system_folders
+        )

vantage6/cli/context/base_server.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import os.path
+
+from sqlalchemy.engine.url import make_url
+
+from vantage6.common.context import AppContext
+from vantage6.cli.globals import (
+    DEFAULT_SERVER_SYSTEM_FOLDERS as S_FOL,
+    ServerType,
+)
+
+
+class BaseServerContext(AppContext):
+    """
+    Base context for a vantage6 server or algorithm store server
+
+    Contains functions that the ServerContext and AlgorithmStoreContext have
+    in common.
+    """
+
+    def get_database_uri(self, db_env_var: str) -> str:
+        """
+        Obtain the database uri from the environment or the configuration.
+
+        Parameters
+        ----------
+        db_env_var : str
+            Name of the environment variable that contains the database uri
+
+        Returns
+        -------
+        str
+            string representation of the database uri
+        """
+        uri = os.environ.get(db_env_var) or self.config["uri"]
+        url = make_url(uri)
+
+        if url.host is None and not os.path.isabs(url.database):
+            # We're dealing with a relative path here of a local database, when
+            # we're running the server outside of docker. Therefore we need to
+            # prepend the data directory to the database name, but after the
+            # driver name (e.g. sqlite:////db.sqlite ->
+            # sqlite:////data_dir>/db.sqlite)
+
+            # find index of database name
+            idx_db_name = str(url).find(url.database)
+
+            # add the datadir to the right location in the database uri
+            return str(url)[:idx_db_name] + str(self.data_dir / url.database)
+
+        return uri
+
+    @classmethod
+    def from_external_config_file(
+        cls,
+        path: str,
+        server_type: ServerType,
+        config_name_env_var: str,
+        system_folders: bool = S_FOL,
+    ) -> BaseServerContext:
+        """
+        Create a server context from an external configuration file. External
+        means that the configuration file is not located in the default folders
+        but its location is specified by the user.
+
+        Parameters
+        ----------
+        path : str
+            Path of the configuration file
+        server_type : ServerType
+            Type of server, either 'server' or 'algorithm-store'
+        config_name_env_var : str
+            Name of the environment variable that contains the name of the
+            configuration
+        system_folders : bool, optional
+            System wide or user configuration, by default S_FOL
+
+        Returns
+        -------
+        ServerContext
+            Server context object
+        """
+        cls = super().from_external_config_file(path, server_type, system_folders)
+        # if we are running a server in a docker container, the name is taken
+        # from the name of the config file (which is usually a default). Get
+        # the config name from environment if it is given.
+        cls.name = os.environ.get(config_name_env_var) or cls.name
+        return cls

vantage6/cli/{context.py → context/node.py}

@@ -1,183 +1,19 @@
-"""
-The context module in the CLI package contains the definition of the
-ServerContext and NodeContext classes. These contexts are related to the host
-system and therefore part of the CLI package.
-
-Both classes are derived from the abstract AppContext class. And provide the
-node and server with naming conventions, standard file locations, and in the
-case of the node with a local database URIs.
-
-*Server Context*
-    A class to provide context for the server, both for development mode as
-    for production.
-
-*Node Context*
-    In case the node is run in development mode, this context will also used by
-    the node package. Normally the node uses the
-    `vantage6.node.context.DockerNodeContext` which provides the same
-    functionality but is tailored to the Docker environment.
-
-"""
-# TODO BvB 2023-01-10 we should have a look at all context classes and define
-# them in the same place. Now the DockerNodeContext is defined in the node, but
-# the server only has a TestServerContext there. This should be made consistent
 from __future__ import annotations
 
 import os.path
 
 from pathlib import Path
 
-from sqlalchemy.engine.url import make_url
-
 from vantage6.common.context import AppContext
-from vantage6.common.globals import APPNAME
-from vantage6.cli.configuration_manager import (
-    NodeConfigurationManager,
-    ServerConfigurationManager,
-)
-from vantage6.cli.globals import (
-    DEFAULT_NODE_SYSTEM_FOLDERS as N_FOL,
-    DEFAULT_SERVER_SYSTEM_FOLDERS as S_FOL,
-)
+from vantage6.common.globals import APPNAME, InstanceType
+from vantage6.cli.configuration_manager import NodeConfigurationManager
+from vantage6.cli.globals import DEFAULT_NODE_SYSTEM_FOLDERS as N_FOL
 from vantage6.cli._version import __version__
 
 
-class ServerContext(AppContext):
-    """
-    Server context
-
-    Parameters
-    ----------
-    instance_name : str
-        Name of the configuration instance, corresponds to the filename
-        of the configuration file.
-    system_folders : bool, optional
-        System wide or user configuration, by default S_FOL
-    """
-
-    # The server configuration manager is aware of the structure of the server
-    # configuration file and makes sure only valid configuration can be loaded.
-    INST_CONFIG_MANAGER = ServerConfigurationManager
-
-    def __init__(self, instance_name: str, system_folders: bool = S_FOL):
-        super().__init__("server", instance_name, system_folders=system_folders)
-        self.log.info(f"vantage6 version '{__version__}'")
-
-    def get_database_uri(self) -> str:
-        """
-        Obtain the database uri from the environment or the configuration. The
-        `VANTAGE6_DB_URI` environment variable is used by the Docker container,
-        but can also be set by the user.
-
-        Returns
-        -------
-        str
-            string representation of the database uri
-        """
-        uri = os.environ.get("VANTAGE6_DB_URI") or self.config["uri"]
-        url = make_url(uri)
-
-        if url.host is None and not os.path.isabs(url.database):
-            # We're dealing with a relative path here of a local database, when
-            # we're running the server outside of docker. Therefore we need to
-            # prepend the data directory to the database name, but after the
-            # driver name (e.g. sqlite:////db.sqlite ->
-            # sqlite:////data_dir>/db.sqlite)
-
-            # find index of database name
-            idx_db_name = str(url).find(url.database)
-
-            # add the datadir to the right location in the database uri
-            return str(url)[:idx_db_name] + str(self.data_dir / url.database)
-
-        return uri
-
-    @property
-    def docker_container_name(self) -> str:
-        """
-        Name of the docker container that the server is running in.
-
-        Returns
-        -------
-        str
-            Server's docker container name
-        """
-        return f"{APPNAME}-{self.name}-{self.scope}-server"
-
-    @classmethod
-    def from_external_config_file(
-        cls, path: str, system_folders: bool = S_FOL
-    ) -> ServerContext:
-        """
-        Create a server context from an external configuration file. External
-        means that the configuration file is not located in the default folders
-        but its location is specified by the user.
-
-        Parameters
-        ----------
-        path : str
-            Path of the configuration file
-        system_folders : bool, optional
-            System wide or user configuration, by default S_FOL
-
-        Returns
-        -------
-        ServerContext
-            Server context object
-        """
-        cls = super().from_external_config_file(path, "server", system_folders)
-        # if we are running a server in a docker container, the name is taken
-        # from the name of the config file (which is usually a default). Get
-        # the config name from environment if it is given.
-        cls.name = os.environ.get("VANTAGE6_CONFIG_NAME") or cls.name
-        return cls
-
-    @classmethod
-    def config_exists(cls, instance_name: str, system_folders: bool = S_FOL) -> bool:
-        """
-        Check if a configuration file exists.
-
-        Parameters
-        ----------
-        instance_name : str
-            Name of the configuration instance, corresponds to the filename
-            of the configuration file.
-        system_folders : bool, optional
-            System wide or user configuration, by default S_FOL
-
-        Returns
-        -------
-        bool
-            Whether the configuration file exists or not
-        """
-        return super().config_exists(
-            "server", instance_name, system_folders=system_folders
-        )
-
-    @classmethod
-    def available_configurations(
-        cls, system_folders: bool = S_FOL
-    ) -> tuple[list, list]:
-        """
-        Find all available server configurations in the default folders.
-
-        Parameters
-        ----------
-        system_folders : bool, optional
-            System wide or user configuration, by default S_FOL
-
-        Returns
-        -------
-        tuple[list, list]
-            The first list contains validated configuration files, the second
-            list contains invalid configuration files.
-        """
-        return super().available_configurations("server", system_folders)
-
-
 class NodeContext(AppContext):
     """
-    Node context
+    Node context object for the host system.
 
     See DockerNodeContext for the node instance mounts when running as a
     dockerized service.
@@ -200,8 +36,8 @@ class NodeContext(AppContext):
     def __init__(
         self, instance_name: str, system_folders: bool = N_FOL, config_file: str = None
     ):
-        super().__init__("node", instance_name, system_folders, config_file)
-        self.log.info(f"vantage6 version '{__version__}'")
+        super().__init__(InstanceType.NODE, instance_name, system_folders, config_file)
+        self.log.info("vantage6 version '%s'", __version__)
 
     @classmethod
     def from_external_config_file(
@@ -224,7 +60,9 @@ class NodeContext(AppContext):
         NodeContext
             Node context object
         """
-        return super().from_external_config_file(path, "node", system_folders)
+        return super().from_external_config_file(
+            path, InstanceType.NODE, system_folders
+        )
 
     @classmethod
     def config_exists(cls, instance_name: str, system_folders: bool = N_FOL) -> bool:
@@ -245,7 +83,7 @@ class NodeContext(AppContext):
             Whether the configuration file exists or not
         """
         return super().config_exists(
-            "node", instance_name, system_folders=system_folders
+            InstanceType.NODE, instance_name, system_folders=system_folders
         )
 
     @classmethod
@@ -266,7 +104,7 @@ class NodeContext(AppContext):
             The first list contains validated configuration files, the second
             list contains invalid configuration files.
         """
-        return super().available_configurations("node", system_folders)
+        return super().available_configurations(InstanceType.NODE, system_folders)
 
     @staticmethod
     def type_data_folder(system_folders: bool = N_FOL) -> Path:
@@ -283,7 +121,7 @@ class NodeContext(AppContext):
         Path
             Path to the data folder
         """
-        return AppContext.type_data_folder("node", system_folders)
+        return AppContext.type_data_folder(InstanceType.NODE, system_folders)
 
     @property
     def databases(self) -> dict:

vantage6/cli/context/server.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+from vantage6.common.globals import APPNAME, InstanceType
+from vantage6.cli.configuration_manager import ServerConfigurationManager
+from vantage6.cli.globals import (
+    DEFAULT_SERVER_SYSTEM_FOLDERS as S_FOL,
+    ServerType,
+    ServerGlobals,
+)
+from vantage6.cli._version import __version__
+from vantage6.cli.context.base_server import BaseServerContext
+
+
+class ServerContext(BaseServerContext):
+    """
+    Server context
+
+    Parameters
+    ----------
+    instance_name : str
+        Name of the configuration instance, corresponds to the filename
+        of the configuration file.
+    system_folders : bool, optional
+        System wide or user configuration, by default S_FOL
+    """
+
+    # The server configuration manager is aware of the structure of the server
+    # configuration file and makes sure only valid configuration can be loaded.
+    INST_CONFIG_MANAGER = ServerConfigurationManager
+
+    def __init__(self, instance_name: str, system_folders: bool = S_FOL):
+        super().__init__(
+            InstanceType.SERVER, instance_name, system_folders=system_folders
+        )
+        self.log.info("vantage6 version '%s'", __version__)
+
+    def get_database_uri(self) -> str:
+        """
+        Obtain the database uri from the environment or the configuration. The
+        `VANTAGE6_DB_URI` environment variable is used by the Docker container,
+        but can also be set by the user.
+
+        Returns
+        -------
+        str
+            string representation of the database uri
+        """
+        return super().get_database_uri(ServerGlobals.DB_URI_ENV_VAR)
+
+    @property
+    def docker_container_name(self) -> str:
+        """
+        Name of the docker container that the server is running in.
+
+        Returns
+        -------
+        str
+            Server's docker container name
+        """
+        return f"{APPNAME}-{self.name}-{self.scope}-{ServerType.V6SERVER}"
+
+    @classmethod
+    def from_external_config_file(
+        cls, path: str, system_folders: bool = S_FOL
+    ) -> ServerContext:
+        """
+        Create a server context from an external configuration file. External
+        means that the configuration file is not located in the default folders
+        but its location is specified by the user.
+
+        Parameters
+        ----------
+        path : str
+            Path of the configuration file
+        system_folders : bool, optional
+            System wide or user configuration, by default S_FOL
+
+        Returns
+        -------
+        ServerContext
+            Server context object
+        """
+        return super().from_external_config_file(
+            path, ServerType.V6SERVER, ServerGlobals.CONFIG_NAME_ENV_VAR, system_folders
+        )
+
+    @classmethod
+    def config_exists(cls, instance_name: str, system_folders: bool = S_FOL) -> bool:
+        """
+        Check if a configuration file exists.
+
+        Parameters
+        ----------
+        instance_name : str
+            Name of the configuration instance, corresponds to the filename
+            of the configuration file.
+        system_folders : bool, optional
+            System wide or user configuration, by default S_FOL
+
+        Returns
+        -------
+        bool
+            Whether the configuration file exists or not
+        """
+        return super().config_exists(
+            InstanceType.SERVER, instance_name, system_folders=system_folders
+        )
+
+    @classmethod
+    def available_configurations(
+        cls, system_folders: bool = S_FOL
+    ) -> tuple[list, list]:
+        """
+        Find all available server configurations in the default folders.
+
+        Parameters
+        ----------
+        system_folders : bool, optional
+            System wide or user configuration, by default S_FOL
+
+        Returns
+        -------
+        tuple[list, list]
+            The first list contains validated configuration files, the second
+            list contains invalid configuration files.
+        """
+        return super().available_configurations(InstanceType.SERVER, system_folders)

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
@@ -233,7 +234,7 @@ def create_vserver_import_config(node_configs: list[dict], server_name: str) ->
     server_import_config = template.render(
         organizations=organizations, collaboration=collaboration
     )
-    folders = ServerContext.instance_folders("server", server_name, False)
+    folders = ServerContext.instance_folders(InstanceType.SERVER, server_name, False)
 
     demo_dir = Path(folders["dev"])
     demo_dir.mkdir(parents=True, exist_ok=True)

vantage6/cli/dev/remove.py

@@ -6,10 +6,12 @@ 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()
@@ -30,14 +32,14 @@ def remove_demo_network(click_ctx: click.Context, ctx: ServerContext) -> None:
     # removing the server import config
     info("Deleting demo import config file")
     server_configs = ServerContext.instance_folders(
-        "server", ctx.name, system_folders=False
+        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
+        InstanceType.SERVER, ctx.name, system_folders=True
     )
     server_folder = server_configs["data"]
     if server_folder.is_dir():

vantage6/cli/dev/start.py

@@ -1,7 +1,8 @@
 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
 

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

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