vantage6-algorithm-tools 5.0.0b1__tar.gz → 5.0.0b4__tar.gz

{vantage6_algorithm_tools-5.0.0b1 → vantage6_algorithm_tools-5.0.0b4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vantage6-algorithm-tools
-Version: 5.0.0b1
+Version: 5.0.0b4
 Summary: Vantage6 algorithm tools
 Author: Vantage6 Team
 Maintainer-email: Frank Martin <f.martin@iknl.nl>, Bart van Beusekom <b.vanbeusekom@iknl.nl>
@@ -14,7 +14,7 @@ Requires-Dist: pyfiglet==1.0.4
 Requires-Dist: pyjwt==2.9.0
 Requires-Dist: sparqlwrapper>=2.0.0
 Requires-Dist: sqlalchemy>=1.4.46
-Requires-Dist: vantage6-common==5.0.0b1
+Requires-Dist: vantage6-common==5.0.0b4
 Provides-Extra: dev
 Requires-Dist: black; extra == 'dev'
 Requires-Dist: coverage==7.10.2; extra == 'dev'

{vantage6_algorithm_tools-5.0.0b1 → vantage6_algorithm_tools-5.0.0b4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "vantage6-algorithm-tools"
-version = "5.0.0b1"
+version = "5.0.0b4"
 description = "Vantage6 algorithm tools"
 readme = "README.md"
 license = {text = "MIT"}
@@ -27,7 +27,7 @@ dependencies = [
     "pyfiglet==1.0.4",
     "SPARQLWrapper>=2.0.0",
     "sqlalchemy>=1.4.46",
-    "vantage6-common==5.0.0b1",
+    "vantage6-common==5.0.0b4",
 ]
 
 [project.optional-dependencies]

{vantage6_algorithm_tools-5.0.0b1 → vantage6_algorithm_tools-5.0.0b4}/tests/algorithm/test___init__.py

@@ -29,7 +29,7 @@ class TestAlgorithmClient(unittest.TestCase):
         dummy_token = jwt.encode(payload, key="", algorithm=None)
         self.client = AlgorithmClient(
             token=dummy_token,
-            server_url="http://dummy_host:1234",
+            hq_url="http://dummy_host:1234",
         )
         self.client.parent = MagicMock()
         self.client.parent.request = MagicMock()
@@ -89,9 +89,7 @@ class TestAlgorithmClient(unittest.TestCase):
         self.assertEqual(results[0], {"foo": "bar"})
 
     @patch("vantage6.algorithm.client.AlgorithmClient._multi_page_request")
-    @patch(
-        "vantage6.common.client.client_base.ClientBase._download_run_data_from_server"
-    )
+    @patch("vantage6.common.client.client_base.ClientBase._download_run_data_from_hq")
     def test_result_from_task_azure(
         self, mock_download_run_data, mock_multi_page_request
     ):
@@ -100,7 +98,7 @@ class TestAlgorithmClient(unittest.TestCase):
                 self.client.result.parent, "_multi_page_request"
             ) as mock_multi_page_request,
             patch.object(
-                self.client.result.parent, "_download_run_data_from_server"
+                self.client.result.parent, "_download_run_data_from_hq"
             ) as mock_download_run_data,
         ):
             # Simulate a result where blob_storage_used is True

{vantage6_algorithm_tools-5.0.0b1 → vantage6_algorithm_tools-5.0.0b4}/tests/mock/test_network.py

@@ -6,8 +6,8 @@ import pandas as pd
 from vantage6.algorithm.data_extraction.mock_extract import MockDatabaseType
 from vantage6.algorithm.mock import MockNetwork
 from vantage6.algorithm.mock.client import MockUserClient
+from vantage6.algorithm.mock.hq import MockHQ
 from vantage6.algorithm.mock.node import MockNode
-from vantage6.algorithm.mock.server import MockServer
 
 TEST_ALGORITHM_NAME = "test_algorithm"
 DATASET_LABEL = "dataset_1"
@@ -58,8 +58,8 @@ class TestMockNetworkDataframe(TestCase):
 
     def test_attributes(self):
         """Test if properties are properly initialized"""
-        # Check the type of the server
-        self.assertIsInstance(self.network.server, MockServer)
+        # Check the types
+        self.assertIsInstance(self.network.hq, MockHQ)
         self.assertIsInstance(self.network.user_client, MockUserClient)
 
         self.assertEqual(len(self.network.nodes), 2)
@@ -79,11 +79,11 @@ class TestMockNetworkDataframe(TestCase):
         self.assertIsInstance(self.network.get_node(1), MockNode)
         self.assertIsInstance(self.network.get_node(2), MockNode)
 
-    def test_server_initialization(self):
-        """Test if server is properly initialized"""
-        self.assertEqual(len(self.network.server.tasks), 0)
-        self.assertEqual(len(self.network.server.runs), 0)
-        self.assertEqual(len(self.network.server.results), 0)
+    def test_hq_initialization(self):
+        """Test if HQ is properly initialized"""
+        self.assertEqual(len(self.network.hq.tasks), 0)
+        self.assertEqual(len(self.network.hq.runs), 0)
+        self.assertEqual(len(self.network.hq.results), 0)
 
     def test_node_initialization(self):
         """Test if node is properly initialized"""

{vantage6_algorithm_tools-5.0.0b1 → vantage6_algorithm_tools-5.0.0b4}/tests/mock/test_node.py

@@ -50,9 +50,9 @@ class TestMockNodeDataframe(TestCase):
     def test_simulate_task_run(self):
         """Test if task run simulation works properly"""
 
-        # Mock the server's get_label_for_df_id to return the correct label
-        self.network.server = MagicMock()
-        self.network.server.get_label_for_df_id = MagicMock(return_value=LABEL_1)
+        # Mock the HQ's get_label_for_df_id to return the correct label
+        self.network.hq = MagicMock()
+        self.network.hq.get_label_for_df_id = MagicMock(return_value=LABEL_1)
 
         # Create a mock method function
         mock_method = MagicMock()
@@ -186,8 +186,8 @@ class TestMockNodeDataframe(TestCase):
 
     def test_task_env_vars(self):
         """Test if _task_env_vars returns correct environment variables"""
-        # Mock the server tasks to simulate task count
-        self.network.server.tasks = [1, 2, 3]  # 3 existing tasks
+        # Mock the HQ tasks to simulate task count
+        self.network.hq.tasks = [1, 2, 3]  # 3 existing tasks
 
         # Call _task_env_vars with test values
         action = AlgorithmStepType.FEDERATED_COMPUTE

{vantage6_algorithm_tools-5.0.0b1 → vantage6_algorithm_tools-5.0.0b4}/tests/mock/test_server.py

@@ -2,10 +2,10 @@ import json
 from unittest import TestCase
 
 from vantage6.algorithm.mock import MockNetwork
-from vantage6.algorithm.mock.server import MockServer
+from vantage6.algorithm.mock.hq import MockHQ
 
 
-class TestMockServer(TestCase):
+class TestMockHQ(TestCase):
     def setUp(self):
         """Set up test fixtures"""
         self.network = MockNetwork(
@@ -21,23 +21,23 @@ class TestMockServer(TestCase):
             ],
             collaboration_id=1,
         )
-        self.server = MockServer(self.network)
+        self.hq = MockHQ(self.network)
 
     def test_initialization(self):
-        """Test if server is properly initialized"""
-        self.assertEqual(self.server.network.collaboration_id, 1)
-        self.assertEqual(self.server.session_id, 1)
-        self.assertEqual(self.server.study_id, 1)
-        self.assertEqual(len(self.server.tasks), 0)
-        self.assertEqual(len(self.server.runs), 0)
-        self.assertEqual(len(self.server.results), 0)
+        """Test if HQ is properly initialized"""
+        self.assertEqual(self.hq.network.collaboration_id, 1)
+        self.assertEqual(self.hq.session_id, 1)
+        self.assertEqual(self.hq.study_id, 1)
+        self.assertEqual(len(self.hq.tasks), 0)
+        self.assertEqual(len(self.hq.runs), 0)
+        self.assertEqual(len(self.hq.results), 0)
 
     def test_save_result(self):
         """Test if results are properly saved"""
         test_result = {"test": "data"}
-        result = self.server.save_result(test_result, task_id=1)
+        result = self.hq.save_result(test_result, task_id=1)
 
-        self.assertEqual(len(self.server.results), 1)
+        self.assertEqual(len(self.hq.results), 1)
         self.assertEqual(result["id"], 1)
         self.assertEqual(json.loads(result["result"]), test_result)
         self.assertEqual(result["task"]["id"], 1)
@@ -45,11 +45,9 @@ class TestMockServer(TestCase):
     def test_save_run(self):
         """Test if runs are properly saved"""
         test_args = {"arg1": "value1"}
-        run = self.server.save_run(
-            arguments=test_args, task_id=1, result_id=1, org_id=1
-        )
+        run = self.hq.save_run(arguments=test_args, task_id=1, result_id=1, org_id=1)
 
-        self.assertEqual(len(self.server.runs), 1)
+        self.assertEqual(len(self.hq.runs), 1)
         self.assertEqual(run["id"], 1)
         self.assertEqual(json.loads(run["arguments"]), test_args)
         self.assertEqual(run["task"]["id"], 1)
@@ -59,14 +57,14 @@ class TestMockServer(TestCase):
     def test_save_task(self):
         """Test if tasks are properly saved"""
         test_databases = [{"name": "test_db", "uri": "test_uri"}]
-        task = self.server.save_task(
+        task = self.hq.save_task(
             name="test_task",
             description="test description",
             databases=test_databases,
             init_organization_id=1,
         )
 
-        self.assertEqual(len(self.server.tasks), 1)
+        self.assertEqual(len(self.hq.tasks), 1)
         self.assertEqual(task["id"], 1)
         self.assertEqual(task["name"], "test_task")
         self.assertEqual(task["description"], "test description")

{vantage6_algorithm_tools-5.0.0b1 → vantage6_algorithm_tools-5.0.0b4}/vantage6/algorithm/client/__init__.py

@@ -1,4 +1,4 @@
-"""Client for the algorithm container to communicate with the vantage6 server."""
+"""Client for the algorithm container to communicate with the vantage6 HQ."""
 
 import json
 from typing import Any
@@ -16,29 +16,27 @@ from vantage6.algorithm.tools import __version__  # noqa: F401
 
 class AlgorithmClient(ClientBase):
     """
-    Interface to communicate between the algorithm container and the central
-    server via a local proxy server.
-
-    An algorithm container cannot communicate directly to the
-    central server as it has no internet connection. The algorithm can,
-    however, talk to a local proxy server which has interface to the central
-    server. This way we make sure that the algorithm container does not share
-    details with others, and we also can encrypt the results for a specific
-    receiver. Thus, this not a interface to the central server but to
-    the local proxy server - however, the interface looks identical to make
-    it easier to use.
+    Interface to communicate between the algorithm container and HQ via a local proxy
+    server.
+
+    An algorithm container cannot communicate directly to HQ as it has no internet
+    connection. The algorithm can, however, talk to a local proxy server which has
+    interface to HQ. This way we make sure that the algorithm container does not share
+    details with others, and we also can encrypt the results for a specific receiver.
+    Thus, this not a interface to HQ but to the local proxy server - however, the
+    interface looks identical to make it easier to use.
 
     Parameters
     ----------
     token: str
         JWT (container) token, generated by the node the algorithm container
         runs on
-    server_url : str
-        The url of the server to connect to.
+    hq_url : str
+        The url of HQ to connect to.
     """
 
-    def __init__(self, token: str, server_url: str) -> None:
-        super().__init__(server_url=server_url)
+    def __init__(self, token: str, hq_url: str) -> None:
+        super().__init__(hq_url=hq_url)
 
         # obtain the identity from the token
         jwt_payload = jwt.decode(
@@ -74,7 +72,7 @@ class AlgorithmClient(ClientBase):
 
     def request(self, *args, **kwargs) -> dict:
         """
-        Make a request to the central server. This overwrites the parent
+        Make a request to HQ. This overwrites the parent
         function so that containers will not try to refresh their token, which
         they would be unable to do.
 
@@ -86,7 +84,7 @@ class AlgorithmClient(ClientBase):
         Returns
         -------
         dict
-            Response from the central server.
+            Response from HQ.
         """
         return super().request(*args, **kwargs, retry=False)
 
@@ -119,15 +117,14 @@ class AlgorithmClient(ClientBase):
 
     def wait_for_results(self, task_id: int, interval: float = 1) -> list:
         """
-        Poll the central server until results are available and then return
-        them
+        Poll HQ until results are available and then return them.
 
         Parameters
         ----------
         task_id: int
             ID of the task for which the results should be obtained.
         interval: float
-            Interval in seconds to wait between checking server for results.
+            Interval in seconds to wait between checking HQ for results.
 
         Returns
         -------
@@ -141,8 +138,7 @@ class AlgorithmClient(ClientBase):
 
     def _multi_page_request(self, endpoint: str, params: dict = None) -> dict:
         """
-        Make multiple requests to the central server to get all pages of a list
-        of results.
+        Make multiple requests to HQ to get all pages of a list of results.
 
         Parameters
         ----------
@@ -154,7 +150,7 @@ class AlgorithmClient(ClientBase):
         Returns
         -------
         dict
-            Response from the central server.
+            Response from HQ.
         """
         if params is None:
             params = {}
@@ -176,14 +172,11 @@ class AlgorithmClient(ClientBase):
     class Run(ClientBase.SubClient):
         """
         Algorithm Run client for the algorithm container.
-
-        This client is used to obtain algorithm runs of tasks with the same
-        job_id from the central server.
         """
 
         def get(self, id_) -> dict:
             """
-            Obtain a specific algorithm run from the central server.
+            Obtain a specific algorithm run from HQ.
 
             Parameters
             ----------
@@ -199,11 +192,10 @@ class AlgorithmClient(ClientBase):
 
         def from_task(self, task_id: int) -> list:
             """
-            Obtain algorithm runs from a specific task at the server.
+            Obtain algorithm runs from a specific task at HQ.
 
             Containers are allowed to obtain the runs of their children
-            (having the same job_id at the server). The permissions are checked
-            at te central server.
+            (having the same job_id at HQ). The permissions are checked at HQ.
 
             Note that the returned results are not decrypted. The algorithm is
             responsible for decrypting the results.
@@ -227,13 +219,11 @@ class AlgorithmClient(ClientBase):
     class Result(ClientBase.SubClient):
         """
         Result client for the algorithm container.
-
-        This client is used to get results from the central server.
         """
 
         def get(self, id_: int) -> Any:
             """
-            Obtain a specific result from the central server.
+            Obtain a specific result from HQ.
 
             Parameters
             ----------
@@ -263,17 +253,16 @@ class AlgorithmClient(ClientBase):
 
         def from_task(self, task_id: int) -> list[Any]:
             """
-            Obtain results from a specific task at the server.
+            Obtain results from a specific task at HQ.
 
             Containers are allowed to obtain the results of their children
-            (having the same job_id at the server). The permissions are checked
-            at te central server.
+            (having the same job_id at HQ). The permissions are checked at HQ.
 
             Results are decrypted by the proxy server and decoded here before
             returning them to the algorithm.
 
             If blob storage was used to store the results, the results
-            will be streamed from blob storage, through the server and proxy,
+            will be streamed from blob storage, through HQ and proxy,
             and decryption will take place on a chunk-by-chunk basis.
 
             Parameters
@@ -294,9 +283,7 @@ class AlgorithmClient(ClientBase):
                     return None
                 try:
                     if run.get("blob_storage_used", False):
-                        run_data = self.parent._download_run_data_from_server(
-                            result_data
-                        )
+                        run_data = self.parent._download_run_data_from_hq(result_data)
                         return json.loads(run_data.decode(STRING_ENCODING))
                     else:
                         return json.loads(base64s_to_bytes(result_data).decode())
@@ -322,7 +309,7 @@ class AlgorithmClient(ClientBase):
 
         def get(self, task_id: int) -> dict:
             """
-            Retrieve a task at the central server.
+            Retrieve a task at HQ.
 
             Parameters
             ----------
@@ -345,15 +332,13 @@ class AlgorithmClient(ClientBase):
             description: str = None,
         ) -> dict:
             """
-            Create a new (child) task at the central server.
+            Create a new (child) task at HQ.
 
-            Containers are allowed to create child tasks (having the
-            same job_id) at the central server. The docker image must
-            be the same as the docker image of this container self.
+            Containers are allowed to create child tasks (having the same job_id) at HQ.
 
-            If blob storage is configured at the server, the input arguments data
-            will be uploaded to blob storage and a UUID reference will be
-            passed as a result instead.
+            If blob storage is configured at HQ, the input arguments data will be
+            uploaded to blob storage and a UUID reference will be passed as a result
+            instead.
 
             Parameters
             ----------
@@ -404,7 +389,7 @@ class AlgorithmClient(ClientBase):
                         "Blob store is enabled, uploading arguments data to blob "
                         "storage."
                     )
-                    arguments_uuid = self.parent._upload_run_data_to_server(
+                    arguments_uuid = self.parent._upload_run_data_to_hq(
                         serialized_arguments, pub_key=pub_key
                     )
                     org_arguments = arguments_uuid

{vantage6_algorithm_tools-5.0.0b1 → vantage6_algorithm_tools-5.0.0b4}/vantage6/algorithm/decorator/algorithm_client.py

@@ -19,7 +19,7 @@ def _algorithm_client() -> Callable:
 
     By adding @algorithm_client to a function, the ``algorithm_client``
     argument will be added to the front of the argument list. This client can
-    be used to communicate with the server.
+    be used to communicate with the vantage6 hub.
 
     There is one reserved argument `mock_client` in the function to be
     decorated. If this argument is provided, the decorator will add this
@@ -71,12 +71,12 @@ def _algorithm_client() -> Callable:
                 )
                 exit(1)
 
-            # read server address from the environment
+            # read HQ address from the environment
             host = os.environ[ContainerEnvNames.HOST.value]
             port = os.environ[ContainerEnvNames.PORT.value]
             api_path = os.environ[ContainerEnvNames.API_PATH.value]
 
-            client = AlgorithmClient(token=token, server_url=f"{host}:{port}{api_path}")
+            client = AlgorithmClient(token=token, hq_url=f"{host}:{port}{api_path}")
             return func(client, *args, **kwargs)
 
         # set attribute that this function is wrapped in an algorithm client

{vantage6_algorithm_tools-5.0.0b1 → vantage6_algorithm_tools-5.0.0b4}/vantage6/algorithm/mock/client.py

@@ -34,15 +34,14 @@ class MockBaseClient:
                 "_access_token",
                 "_ClientBase__auth_url",
                 "_ClientBase__check_algorithm_store_valid",
-                "_ClientBase__server_url",
+                "_ClientBase__hq_url",
                 "_decrypt_run_data",
                 "_decrypt_field",
-                "_download_run_data_from_server",
+                "_download_run_data_from_hq",
                 "_fetch_and_decrypt_run_data",
                 "_multi_page_request",
                 "_refresh_token",
-                "_refresh_url",
-                "_upload_run_data_to_server",
+                "_upload_run_data_to_hq",
                 "auth_url",
                 "authenticate",
                 "check_if_blob_store_enabled",
@@ -57,7 +56,7 @@ class MockBaseClient:
                 "node_id",
                 "obtain_new_token",
                 "request",
-                "server_url",
+                "hq_url",
                 "session_id",
                 "setup_encryption",
                 "store_id",
@@ -168,7 +167,7 @@ class MockBaseClient:
             dict
                 Dictionary containing study data.
             """
-            return self.parent.network.server.study
+            return self.parent.network.hq.study
 
     class Task(SubClient):
         """
@@ -238,7 +237,7 @@ class MockBaseClient:
             if not databases:
                 databases = []
 
-            task = self.parent.network.server.save_task(
+            task = self.parent.network.hq.save_task(
                 init_organization_id=self.parent.organization_id,
                 name=name,
                 description=description,
@@ -277,10 +276,8 @@ class MockBaseClient:
                     traceback.print_exc()
                     exit(1)
 
-                result_response = self.parent.network.server.save_result(
-                    result, task["id"]
-                )
-                self.parent.network.server.save_run(
+                result_response = self.parent.network.hq.save_result(result, task["id"])
+                self.parent.network.hq.save_run(
                     arguments, task["id"], result_response["id"], org_id
                 )
 
@@ -311,7 +308,7 @@ class MockBaseClient:
             dict
                 A mocked run.
             """
-            for run in self.parent.network.server.runs:
+            for run in self.parent.network.hq.runs:
                 if run.get("id") == id_:
                     return run
             return {"msg": f"Could not find run with id {id_}"}
@@ -331,7 +328,7 @@ class MockBaseClient:
                 A list of mocked runs.
             """
             runs = []
-            for run in self.parent.network.server.runs:
+            for run in self.parent.network.hq.runs:
                 if run.get("task").get("id") == task_id:
                     runs.append(run)
             return runs
@@ -355,7 +352,7 @@ class MockBaseClient:
             Any
                 A mocked result.
             """
-            for result in self.network.parent.server.results:
+            for result in self.network.parent.hq.results:
                 if result.get("id") == id_:
                     return json.loads(result.get("result"))
             return {"msg": f"Could not find result with id {id_}"}
@@ -375,7 +372,7 @@ class MockBaseClient:
                 The results of the task.
             """
             results = []
-            for result in self.parent.network.server.results:
+            for result in self.parent.network.hq.results:
                 if result.get("task").get("id") == task_id:
                     results.append(json.loads(result.get("result")))
             return results
@@ -477,7 +474,7 @@ class MockBaseClient:
             dict
                 A mocked collaboration.
             """
-            id_ = self.parent.network.server.collaboration_id
+            id_ = self.parent.network.hq.collaboration_id
             return {
                 "id": id_,
                 "name": "mock-collaboration",
@@ -530,6 +527,11 @@ class MockUserClient(MockBaseClient):
                 "setup_collaboration",
                 "User",
                 "Util",
+                "_try_open_browser_for_device_flow",
+                "_get_device_flow_endpoints",
+                "_poll_device_token",
+                "_start_device_authorization",
+                "_finalize_successful_authentication",
             ]
         )
 
@@ -545,7 +547,7 @@ class MockUserClient(MockBaseClient):
             """
             Get dataframe by ID
             """
-            for dataframe in self.parent.network.server.dataframes:
+            for dataframe in self.parent.network.hq.dataframes:
                 if dataframe.get("id") == id_:
                     return dataframe
             return {"msg": f"Could not find dataframe with id {id_}"}
@@ -561,7 +563,7 @@ class MockUserClient(MockBaseClient):
             if not arguments:
                 arguments = {}
 
-            task = self.parent.network.server.save_task(
+            task = self.parent.network.hq.save_task(
                 init_organization_id=self.parent.organization_id,
                 name=name,
                 description=f"Mock dataframe creation for {label}",
@@ -594,12 +596,12 @@ class MockUserClient(MockBaseClient):
 
                 # In case of a dataframe we do not store a result, as the dataframe
                 # creation on the node is the result of this action.
-                result_response = self.parent.network.server.save_result({}, task["id"])
-                self.parent.network.server.save_run(
+                result_response = self.parent.network.hq.save_result({}, task["id"])
+                self.parent.network.hq.save_run(
                     arguments, task["id"], result_response["id"], org_id
                 )
 
-            dataframe = self.parent.network.server.save_dataframe(
+            dataframe = self.parent.network.hq.save_dataframe(
                 name=name,
                 dataframes=dataframes,
                 source_db_label=label,
@@ -611,12 +613,12 @@ class MockUserClient(MockBaseClient):
             self, id_: int, image: str, method: str, arguments: dict
         ) -> dict:
             """ """
-            dataframe = self.parent.network.server.get_dataframe(id_)
+            dataframe = self.parent.network.hq.get_dataframe(id_)
             data_frame_name = dataframe.get("name")
             if not dataframe or not data_frame_name:
                 return {"msg": f"An error occurred while fetching dataframe {id_}"}
 
-            task = self.parent.network.server.save_task(
+            task = self.parent.network.hq.save_task(
                 init_organization_id=self.parent.organization_id,
                 name=f"Preprocess {data_frame_name}",
                 description=f"Preprocess {data_frame_name}",
@@ -644,18 +646,18 @@ class MockUserClient(MockBaseClient):
                     exit(1)
                 dataframes.append(df)
 
-                result_response = self.parent.network.server.save_result({}, task["id"])
-                self.parent.network.server.save_run(
+                result_response = self.parent.network.hq.save_result({}, task["id"])
+                self.parent.network.hq.save_run(
                     arguments, task["id"], result_response["id"], org_id
                 )
 
-            return self.parent.network.server.update_dataframe(id_, dataframes)
+            return self.parent.network.hq.update_dataframe(id_, dataframes)
 
         def list(self) -> list[dict]:
             """
             List all dataframes
             """
-            return self.parent.network.server.dataframes
+            return self.parent.network.hq.dataframes
 
 
 class MockAlgorithmClient(MockBaseClient):
@@ -667,7 +669,7 @@ class MockAlgorithmClient(MockBaseClient):
         self.image = "mock-image"
         self.node_id = node.id_
         self.collaboration_id = node.collaboration_id
-        self.study_id = node.network.server.study_id
+        self.study_id = node.network.hq.study_id
         self.organization_id = node.organization_id
         self.databases = databases
 

vantage6_algorithm_tools-5.0.0b1/vantage6/algorithm/mock/server.py → vantage6_algorithm_tools-5.0.0b4/vantage6/algorithm/mock/hq.py

@@ -10,23 +10,23 @@ if TYPE_CHECKING:
     from vantage6.algorithm.mock.network import MockNetwork
 
 
-class MockServer:
+class MockHQ:
     def __init__(self, network: "MockNetwork"):
         """
-        Create a mock server.
+        Create a mock HQ.
 
-        Typically, you do not need to create a mock server manually. Instead, you should
-        use the MockNetwork class to create a mock network.
+        Typically, you do not need to create a mock HQ manually. Instead, you should
+        use the MockNetwork class to create a mock network, which contains a mock HQ.
 
         Parameters
         ----------
-        collaboration_id : int
-            The id of the collaboration, used to format the responses.
+        network : MockNetwork
+            The network that the HQ belongs to.
         """
         self.network = network
 
         # These contain the task, runs, results and dataframes as dictionaries that are
-        # the same format as you would get from the server responses.
+        # the same format as you would get from the HQ responses.
         self.tasks = []
         self.runs = []
         self.results = []
@@ -45,18 +45,18 @@ class MockServer:
         return {
             "collaboration": {
                 "id": self.network.collaboration_id,
-                "link": f"/server/collaboration/{self.network.collaboration_id}",
+                "link": f"/hq/collaboration/{self.network.collaboration_id}",
                 "methods": ["PATCH", "GET", "DELETE"],
             },
-            "organizations": f"/server/organization?study_id={self.study_id}",
-            "tasks": f"/server/task?study_id={self.study_id}",
+            "organizations": f"/hq/organization?study_id={self.study_id}",
+            "tasks": f"/hq/task?study_id={self.study_id}",
             "name": "Mock Study",
             "id": self.study_id,
         }
 
     def save_result(self, result: Any, task_id: int):
         """
-        Save a result to the mock server.
+        Save a result to the mock HQ.
 
         Parameters
         ----------
@@ -92,7 +92,7 @@ class MockServer:
         self, arguments: dict, task_id: int, result_id: int, org_id: int
     ) -> dict:
         """
-        Save a run to the mock server.
+        Save a run to the mock HQ.
 
         Parameters
         ----------
@@ -153,7 +153,7 @@ class MockServer:
         init_organization_id: int,
     ) -> dict:
         """
-        Save a task to the mock server.
+        Save a task to the mock HQ.
 
         Parameters
         ----------
@@ -245,8 +245,8 @@ class MockServer:
                 "link": f"/api/session/{self.session_id}",
                 "methods": ["GET", "PATCH", "DELETE"],
             },
-            "tasks": {"msg": "not implemented in the MockNetwork"},
-            "last_session_task": {"msg": "not implemented in the MockNetwork"},
+            "tasks": {"msg": "not implemented in the MockHQ"},
+            "last_session_task": {"msg": "not implemented in the MockHQ"},
             "columns": [
                 {
                     "name": column,

{vantage6_algorithm_tools-5.0.0b1 → vantage6_algorithm_tools-5.0.0b4}/vantage6/algorithm/mock/network.py

@@ -7,8 +7,8 @@ from vantage6.algorithm.tools.util import error
 
 from vantage6.algorithm.mock.client import MockUserClient
 from vantage6.algorithm.mock.globals import MockDatabase
+from vantage6.algorithm.mock.hq import MockHQ
 from vantage6.algorithm.mock.node import MockNode
-from vantage6.algorithm.mock.server import MockServer
 
 
 class MockNetwork:
@@ -44,8 +44,8 @@ class MockNetwork:
         ----------
         nodes : list[MockNode]
             The nodes of the mock network.
-        server : MockServer
-            The server of the mock network.
+        hq : MockHQ
+            The HQ of the mock network.
         user_client : MockUserClient
             The user client of the mock network.
 
@@ -120,7 +120,7 @@ class MockNetwork:
         organization_ids = list(range(1, len(datasets) + 1))
         node_ids = list(range(1, len(datasets) + 1))
 
-        self.server = MockServer(self)
+        self.hq = MockHQ(self)
 
         databases = [
             [
@@ -151,7 +151,7 @@ class MockNetwork:
                 exit(1)
 
         # In the case the user provides a pandas DataFrame we need to create a dataframe
-        # record in the server.
+        # record in HQ.
         dfs_by_label = {}
         for node_databases in databases:
             for database in node_databases:
@@ -161,7 +161,7 @@ class MockNetwork:
 
         for label, dfs in dfs_by_label.items():
             if all(isinstance(df, pd.DataFrame) for df in dfs):
-                self.server.save_dataframe(
+                self.hq.save_dataframe(
                     name=label, dataframes=dfs, source_db_label=label
                 )
 

{vantage6_algorithm_tools-5.0.0b1 → vantage6_algorithm_tools-5.0.0b4}/vantage6/algorithm/mock/node.py

@@ -60,7 +60,7 @@ class MockNode:
         self.dataframes = {}
 
         # In case a pandas dataframe is provided we assume the user directly wants to
-        # use it rather than running an extraction job first.
+        # use it rather than running an extraction algorithm step first.
         for dataset in self.datasets:
             if isinstance(dataset.database, pd.DataFrame):
                 self.dataframes[dataset.label] = dataset.database
@@ -138,16 +138,14 @@ class MockNode:
                 for db_group in databases:
                     group_data = {}
                     for db in db_group:
-                        label = self.network.server.get_label_for_df_id(
-                            db["dataframe_id"]
-                        )
+                        label = self.network.hq.get_label_for_df_id(db["dataframe_id"])
                         self._validate_dataframe_exists(label)
                         group_data[label] = self.dataframes[label]
                     mock_data.append(group_data)
             else:
                 # Single list format
                 for db in databases:
-                    label = self.network.server.get_label_for_df_id(db["dataframe_id"])
+                    label = self.network.hq.get_label_for_df_id(db["dataframe_id"])
                     self._validate_dataframe_exists(label)
                     mock_data.append(self.dataframes[label])
 
@@ -303,7 +301,7 @@ class MockNode:
         """
         Get the task environment variables.
         """
-        task_id = len(self.network.server.tasks)
+        task_id = len(self.network.hq.tasks)
         return {
             **self.env,
             ContainerEnvNames.FUNCTION_ACTION.value: action.value,

{vantage6_algorithm_tools-5.0.0b1 → vantage6_algorithm_tools-5.0.0b4}/vantage6/algorithm/tools/wrap.py

@@ -70,7 +70,7 @@ def wrap_algorithm(log_traceback: bool = True) -> None:
     )
 
     # write output from the method to mounted output file. Which will be
-    # transferred back to the server by the node-instance.
+    # transferred back to HQ by the node-instance.
     output_file = os.environ[ContainerEnvNames.OUTPUT_FILE.value]
     info(f"Writing output to {output_file}")
 
@@ -182,9 +182,9 @@ def _write_output(output: Any, output_file: str) -> None:
     """
     Write output to output file.
 
-    In case the result needs to be sent to the server the output file should contain
+    In case the result needs to be sent to HQ, the output file should contain
     valid JSON data. This is because the node will read the output file and send the
-    data to the server.
+    data to HQ.
 
     In the case we are building a session, the output of the algorithm is expected to
     be a parquet table. In this case, the output file should contain the parquet data.