vantage6-algorithm-tools 4.13.4__tar.gz

vantage6_algorithm_tools-4.13.4/PKG-INFO

@@ -0,0 +1,232 @@
+Metadata-Version: 2.4
+Name: vantage6_algorithm_tools
+Version: 4.13.4
+Summary: Vantage6 algorithm tools
+Home-page: https://github.com/vantage6/vantage6
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: openpyxl>=3.0.0
+Requires-Dist: pandas>=1.5.3
+Requires-Dist: pyjwt==2.9.0
+Requires-Dist: pyfiglet==1.0.4
+Requires-Dist: psycopg2-binary==2.9.10
+Requires-Dist: SPARQLWrapper>=2.0.0
+Requires-Dist: sqlalchemy==1.4.46
+Requires-Dist: vantage6-common==4.13.4
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+<h1 align="center">
+  <br>
+  <a href="https://vantage6.ai"><img src="https://github.com/IKNL/guidelines/blob/master/resources/logos/vantage6.png?raw=true" alt="vantage6" width="350"></a>
+</h1>
+
+<h3 align=center> A Privacy Enhancing Technology (PET) Operations platform</h3>
+<h3 align="center">
+
+<!-- Badges go here-->
+
+[![Release](https://github.com/vantage6/vantage6/actions/workflows/release.yml/badge.svg)](https://github.com/vantage6/vantage6/actions/workflows/release.yml)
+[![PyPI vantage6](https://badge.fury.io/py/vantage6.svg)](https://badge.fury.io/py/vantage6)
+[![Unittests](https://github.com/vantage6/vantage6/actions/workflows/unit_tests.yml/badge.svg)](https://github.com/vantage6/vantage6/actions/workflows/unit_tests.yml)
+[![Coverage Status](https://coveralls.io/repos/github/vantage6/vantage6/badge.svg?branch=main)](https://coveralls.io/github/vantage6/vantage6?branch=main)
+[![Codacy Badge](https://app.codacy.com/project/badge/Grade/2e60ac3b3f284620805f7399cba317be)](https://app.codacy.com/gh/vantage6/vantage6/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
+[![DOI](https://zenodo.org/badge/492818831.svg)](https://zenodo.org/badge/latestdoi/492818831)
+[![Discord](https://img.shields.io/discord/643526403207331841)](https://discord.gg/yAyFf6Y)
+[![Research software directory](https://img.shields.io/badge/rsd-vantage6-deepskyblue)](https://research-software-directory.org/software/vantage6)
+
+
+</h3>
+
+<p align="center">
+  <a href="#books-quickstart">Quickstart</a> •
+  <a href="#project-structure">Project structure</a> •
+  <a href="#gift_heart-join-the-community">Join the community</a> •
+  <a href="#scroll-license">License</a> •
+  <a href="#black_nib-code-of-conduct">Code of conduct</a> •
+  <a href="#black_nib-references">References</a>
+</p>
+
+---
+
+This repository is contains all the **vantage6** infrastructure source code. The **vantage6** technology enables to manage and deploy privacy enhancing technologies like Federated Learning (FL) and Multi-Party Computation (MPC). Please visit our [website](https://vantage6.ai) to learn more!
+
+You can find more (user) documentation at [readthedocs](https://docs.vantage6.ai). If you have any questions, suggestions or just want to chat about federated learning: join our [Discord)](https://discord.gg/yAyFf6Y) channel.
+
+## Infrastructure overview
+
+![Vantage6 architecture overview](docs/images/overview-infrastructure.png)
+
+_A High level overview of the vantage6 infrastructure. Vantage6 has both a
+client-server and peer-to-peer architecture. The client is used by the researcher to
+create (PET) computation requests. It is also used to manage users, organizations and
+collaborations. The server contains users, organizations, collaborations, tasks and
+their results. It provides a central access point for both the clients and nodes. The
+nodes have access to privacy sensitive data and handle computation requests retrieved
+from the server. Computation request are executed as separate containers on the node.
+These containers are connected to containers at other nodes by a VPN network._
+
+## :books: Quickstart
+
+### Requirements
+
+The **vantage6** infrastructure is delivered in Docker images. To run these images, you
+need to have [Docker](https://docs.docker.com/get-docker/) installed. To install the
+latest version of the vantage6 CLI, you need to have
+[Python](https://www.python.org/downloads/), we recommend using an environment manager
+like [mini-conda](https://docs.conda.io/en/latest/miniconda.html).
+
+Install the latest version of the vantage6 CLI by using:
+
+```bash
+pip install vantage6
+```
+
+This install the `v6` commands, which allows you to manage your nodes and servers. To view all available options, run:
+
+```bash
+v6 --help
+```
+
+For example you can create a local test setup by using:
+
+```bash
+v6 dev create-demo-network
+```
+
+This creates a local network with a server and two nodes. You can start the network by running:
+
+```bash
+v6 dev start-demo-network
+```
+
+This will start the server and nodes in the background. You can view the logs by running:
+
+```bash
+# View node logs
+v6 node attach
+
+# View server logs
+v6 server attach
+```
+
+From here you can use the [vantage6-client](https://pypi.org/project/vantage6-client)
+to interact with the server. The demo network has a pre-configured organization with
+the following credentials:
+
+- Username: `dev_admin`
+- Password: `password`
+
+For example, you can create a new organization by running:
+
+```python
+from vantage6.client import Client
+
+client = Client('http://127.0.0.1', 7601, '/api', log_level='debug')
+client.authenticate('dev_admin', 'password')
+client.setup_encryption(None)
+
+client.organization.create(
+    name='My organization',
+    address1='My address',
+    address2='My address',
+    zipcode='1234AB',
+    country='The Netherlands',
+    domain='my-organization.com'
+)
+```
+
+You can find more (user) documentation at [readthedocs](https://docs.vantage6.ai)
+
+## Project structure
+
+### PYPI packages
+
+This repository is home to 6 PyPi packages:
+
+- [vantage6](https://pypi.org/project/vantage6) -> _CLI for managing node and server instances_
+- [vantage6-client](https://pypi.org/project/vantage6-client) -> _Python client for interacting with the vantage6-server_
+- [vantage6-algorithm-tools](https://pypi.org/project/vantage6-algorithm-tools) -> _Python tools to facilitate algorithm development_
+- [vantage6-node](https://pypi.org/project/vantage6-node) -> _Node application package_
+- [vantage6-server](https://pypi.org/project/vantage6-server) -> _Server application package_
+- [vantage6-algorithm-store](https://pypi.org/project/vantage6-algorithm-store) -> _Algorithm store application package_
+- [vantage6-common](https://pypi.org/project/vantage6-common) -> _Package with common vantage6 functions_
+- [vantage6-backend-common](https://pypi.org/project/vantage6-backend-common) -> _Package with functions common to central server and algorithm store_
+
+**Note that when using vantage6 you do not install the _server_ and _node_ packages. These are delivered to you in Docker images.**
+
+This repository also hosts the code for the vantage6 user interface (UI). The UI
+is an Angular web application that can be used to interact with the vantage6 server
+easily.
+
+### Docker images
+
+The vantage6 infrastructure is delivered in Docker images. All Docker images are stored
+in our private [Harbor](https://goharbor.io/) registry. The most important images are:
+
+- `harbor2.vantage6.ai/infrastructure/node:VERSION` -> _Node application Docker image_
+- `harbor2.vantage6.ai/infrastructure/server:VERSION` -> _Server application Docker image_
+- `harbor2.vantage6.ai/infrastructure/ui:VERSION` -> _User interface Docker image_
+- `harbor2.vantage6.ai/infrastructure/algorithm-store:VERSION` -> _Algorithm store Docker image_
+
+with `VERSION` being the full semantic version of the vantage6 infrastructure, e.g.
+`4.0.0` or `4.1.0rc0`.
+
+Several other images are used to support the infrastructure:
+
+- `harbor2.vantage6.ai/infrastructure/infrastructure-base:VERSION` -> _Base image for the infrastructure_
+- `harbor2.vantage6.ai/infrastructure/squid:VERSION` -> _Squid proxy image used for the whitelisting service_
+- `harbor2.vantage6.ai/infrastructure/alpine` -> _Alpine image used for vpn traffic forwarding_
+- `harbor2.vantage6.ai/infrastructure/vpn-client` -> _VPN image used to connect to the VPN_
+- `harbor2.vantage6.ai/infrastructure/vpn-configurator` -> _VPN image used for initialization_
+- `harbor2.vantage6.ai/infrastructure/ssh-tunnel` -> _SSH tunnel image used for connecting algorithms to external services_
+
+And finally there are some images released for algorithm development:
+
+- `harbor2.vantage6.ai/infrastructure/algorithm-base:MAJOR.MINOR` -> _Base image for algorithm development_
+- `harbor2.vantage6.ai/infrastructure/algorithm-ohdsi-base:MAJOR.MINOR` -> _Extended algorithm base image for OHDSI algorithm development_
+
+## :gift_heart: Join the community!
+
+We hope to continue developing, improving, and supporting **vantage6** with the help of 
+the federated learning community. If you are interested in contributing, first of all, 
+thank you! Second, please take a look at our 
+[contributing guidelines](https://docs.vantage6.ai/en/main/devops/contribute.html) 
+and our [code of conduct](CODE_OF_CONDUCT.md).
+
+<a href="https://github.com/vantage6/vantage6/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=vantage6/vantage6" />
+</a>
+
+## :scroll: License
+
+This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.
+
+## :black_nib: Code of Conduct
+
+Please note that this project is released with a [Contributor Code of Conduct](CODE_OF_CONDUCT.md). **By participating in any way in this project you agree to abide by its terms.**
+
+## :black_nib: References
+
+If you are using **vantage6**, please cite this repository as well as the accompanying papers as follows:
+
+> - F. Martin, M. Sieswerda, H. Alradhi, et al. vantage6. Available at https://doi.org/10.5281/zenodo.7221216. Accessed on MONTH, 20XX.
+> - A. Moncada-Torres, F. Martin, M. Sieswerda, J. van Soest, G. Gelijnse. VANTAGE6: an open source priVAcy preserviNg federaTed leArninG infrastructurE for Secure Insight eXchange. AMIA Annual Symposium Proceedings, 2020, p. 870-877. [[BibTeX](https://arturomoncadatorres.com/bibtex/moncada-torres2020vantage6.txt), [PDF](https://vantage6.ai/vantage6/)]
+> - D. Smits\*, B. van Beusekom\*, F. Martin, L. Veen, G. Geleijnse, A. Moncada-Torres, An Improved Infrastructure for Privacy-Preserving Analysis of Patient Data, Proceedings of the International Conference of Informatics, Management, and Technology in Healthcare (ICIMTH), vol. 25, 2022, p. 144-147. [[BibTeX](https://arturomoncadatorres.com/bibtex/smits2022improved.txt), [PDF](https://ebooks.iospress.nl/volumearticle/60190)]
+
+---
+
+<p align="center">
+  <a href="https://vantage6.ai">vantage6.ai</a> •
+  <a href="https://discord.gg/yAyFf6Y">Discord</a> •
+  <a href="https://vantage6.discourse.group/">Discourse</a> •
+  <a href="https://docs.vantage6.ai">User documentation</a>
+</p>

vantage6_algorithm_tools-4.13.4/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

vantage6_algorithm_tools-4.13.4/setup.py

@@ -0,0 +1,58 @@
+import codecs
+import os
+
+from os import path
+from setuptools import setup, find_namespace_packages
+from pathlib import Path
+
+# get current directory
+here = Path(path.abspath(path.dirname(__file__)))
+parent_dir = here.parent.absolute()
+
+# get the long description from the README file
+with codecs.open(path.join(parent_dir, "README.md"), encoding="utf-8") as f:
+    long_description = f.read()
+
+# Read the API version from disk. This file should be located in the package
+# folder, since it's also used to set the pkg.__version__ variable.
+version_path = os.path.join(here, "vantage6", "algorithm", "client", "_version.py")
+version_ns = {"__file__": version_path}
+with codecs.open(version_path) as f:
+    exec(f.read(), {}, version_ns)
+
+
+# setup the package
+setup(
+    name="vantage6_algorithm_tools",
+    version=version_ns["__version__"],
+    description="Vantage6 algorithm tools",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/vantage6/vantage6",
+    packages=find_namespace_packages(),
+    python_requires=">=3.6",
+    install_requires=[
+        "openpyxl>=3.0.0",
+        "pandas>=1.5.3",
+        "pyjwt==2.9.0",
+        "pyfiglet==1.0.4",
+        # psycopg2-binary is not used directly in algorithm tools, but is necessary when
+        # running SQL queries on a postgres database.
+        "psycopg2-binary==2.9.10",
+        "SPARQLWrapper>=2.0.0",
+        "sqlalchemy==1.4.46",
+        f'vantage6-common=={version_ns["__version__"]}',
+    ],
+    extras_require={
+        "dev": [
+            "black",
+            "pre-commit",
+        ]
+    },
+    tests_require=["pytest"],
+    package_data={
+        "vantage6.algorithm.client": [
+            "__build__",
+        ],
+    },
+)

vantage6_algorithm_tools-4.13.4/tests/algorithm/test___init__.py

@@ -0,0 +1,128 @@
+import base64
+import unittest
+import json
+import uuid
+import jwt
+
+from unittest.mock import patch, MagicMock
+from vantage6.algorithm.client import AlgorithmClient
+from vantage6.common.globals import STRING_ENCODING
+
+
+def encode_result(result_dict: dict) -> str:
+    """Encode the result dictionary as a base64 string."""
+    return base64.urlsafe_b64encode(json.dumps(result_dict).encode()).decode()
+
+
+class TestAlgorithmClient(unittest.TestCase):
+    def setUp(self):
+        payload = {
+            "sub": {
+                "image": "dummy",
+                "databases": [],
+                "node_id": 1,
+                "collaboration_id": 1,
+            }
+        }
+        dummy_token = jwt.encode(payload, key="", algorithm=None)
+        self.client = AlgorithmClient(
+            token=dummy_token,
+            host="http://dummy_host",
+            port=1234,
+        )
+        self.client.parent = MagicMock()
+        self.client.parent.request = MagicMock()
+        self.client.parent.image = "mock_image"
+        self.client.parent.collaboration_id = 1
+        self.client.parent.databases = []
+        self.client.parent.study_id = None
+        self.client.parent.store_id = None
+        self.client.generate_path_to = MagicMock(
+            return_value="http://mock_blobstream_url"
+        )
+        self.client.parent.request.side_effect = [
+            {"public_key": "mock_public_key"},  # For organization public key
+            {"uuid": "mock_uuid"},  # For blobstream response
+            {"task_id": 123},  # For task creation response
+        ]
+        self.client.log = MagicMock()
+
+    @patch("requests.get")
+    @patch("requests.post")
+    @patch("vantage6.algorithm.client.serialize", return_value=b"serialized_input")
+    def test_create_task(self, mock_serialize, mock_requests_post, mock_requests_get):
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "uuid": "mock_uuid",
+            "public_key": "mock_public_key",
+            "task_id": 123,
+        }
+        mock_requests_post.return_value = mock_response
+
+        mock_requests_get.return_value = mock_response
+
+        input_data = {"method": "mock_method", "args": [1, 2, 3]}
+        organizations = [1]
+        result = self.client.task.create(input_=input_data, organizations=organizations)
+
+        self.assertEqual(
+            result,
+            {"uuid": "mock_uuid", "public_key": "mock_public_key", "task_id": 123},
+        )
+        mock_serialize.assert_called_once_with(input_data)
+
+    @patch("vantage6.algorithm.client.AlgorithmClient._multi_page_request")
+    def test_result_from_task(self, mock_multi_page_request):
+        mock_multi_page_request.return_value = [
+            {
+                "result": encode_result({"foo": "bar"}),  # base64 for '{"foo": "bar"}'
+                "blob_storage_used": None,
+            }
+        ]
+
+        results = self.client.result.from_task(task_id=1)
+        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"
+    )
+    def test_result_from_task_azure(
+        self, mock_download_run_data, mock_multi_page_request
+    ):
+        with patch.object(
+            self.client.result.parent, "_multi_page_request"
+        ) as mock_multi_page_request, patch.object(
+            self.client.result.parent, "_download_run_data_from_server"
+        ) as mock_download_run_data:
+            # Simulate a result where blob_storage_used is True
+            mock_multi_page_request.return_value = [
+                {
+                    "result": str(uuid.uuid4()),
+                    "blob_storage_used": True,
+                }
+            ]
+            expected_value = {"foo": "bar"}
+            mock_download_run_data.return_value = json.dumps(expected_value).encode(
+                STRING_ENCODING
+            )
+            results = self.client.result.from_task(task_id=1)
+            self.assertEqual(results[0], expected_value)
+
+    @patch("vantage6.algorithm.client.AlgorithmClient._multi_page_request")
+    def test_result_from_task_relational(self, mock_multi_page_request):
+        mock_multi_page_request.return_value = [
+            {
+                "result": encode_result({"foo": "bar"}),
+                "blob_storage_used": False,
+            },
+        ]
+
+        results = self.client.result.from_task(task_id=1)
+
+        self.assertEqual(results[0], {"foo": "bar"})
+
+
+if __name__ == "__main__":
+    unittest.main()

vantage6_algorithm_tools-4.13.4/tests/algorithm_module.py

@@ -0,0 +1,5 @@
+import pandas as pd
+
+
+def hello_world(data: pd.DataFrame):
+    return data

vantage6_algorithm_tools-4.13.4/tests/test_deserialization.py

@@ -0,0 +1,15 @@
+from pathlib import Path
+from vantage6.common.client import deserialization
+
+SIMPLE_TARGET_DATA = {"key": "value"}
+
+
+def test_deserialize_json(tmp_path: Path):
+    data = '{"key": "value"}'
+    json_path = tmp_path / "jsonfile.json"
+    json_path.write_text(data)
+
+    with json_path.open("r") as f:
+        result = deserialization.deserialize(f)
+
+        assert SIMPLE_TARGET_DATA == result

vantage6_algorithm_tools-4.13.4/tests/test_docker_wrapper.py

@@ -0,0 +1,127 @@
+# import json
+# from pathlib import Path
+# from unittest.mock import patch, MagicMock
+
+# import pandas as pd
+
+# from vantage6.algorithm.tools import wrapper
+
+# MODULE_NAME = "algorithm_module"
+# DATA = "column1,column2\n1,2"
+# TOKEN = "This is a fake token"
+# INPUT_PARAMETERS = {"method": "hello_world"}
+# SEPARATOR = "."
+# SAMPLE_DB = pd.DataFrame([[1, 2]], columns=["column1", "column2"])
+
+# MOCK_SPARQL_ENDPOINT = "sparql://some_triplestore"
+
+
+# # def test_json_input_without_format_raises_deserializationexception(tmp_path):
+# #     """
+# #     It should only be possible to provide json input if it is preceded by the
+# #     string "json." in unicode. Otherwise a `DeserializationException` should
+# #     be thrown.
+# #     """
+# #     input_file = tmp_path / 'input.json'
+
+# #     with input_file.open('wb') as f:
+# #         f.write(json.dumps(INPUT_PARAMETERS).encode())
+
+# #     with raises(DeserializationException):
+# #         run_docker_wrapper_with_echo_db(input_file, tmp_path)
+
+
+# # def test_json_input_with_format_succeeds(tmp_path):
+# #     input_file = tmp_path / 'input.txt'
+
+# #     with input_file.open('wb') as f:
+# #         f.write(json.dumps(INPUT_PARAMETERS).encode())
+
+# #     output_file = run_docker_wrapper_with_echo_db(input_file, tmp_path)
+# #     assert file_echoes_db(output_file)
+
+
+# # def test_wrapper_serializes_json_output(tmp_path):
+# #     input_parameters = {'method': 'hello_world', 'output_format': JSON_FORMAT}
+# #     input_file = create_pickle_input(tmp_path, input_parameters)
+
+# #     output_file = run_docker_wrapper_with_echo_db(input_file, tmp_path)
+
+# #     with output_file.open('rb') as f:
+# #         # Check whether the data is preceded by json format string
+# #         assert f.read(len(JSON_FORMAT) + 1).decode() == f'{JSON_FORMAT}.'
+
+# #         # Since the echo_db algorithm was triggered, output will be table that
+# #         # can be read by pandas.
+# #         result = pd.read_json(f.read())
+# #         pd.testing.assert_frame_equal(SAMPLE_DB, result)
+
+
+# def run_docker_wrapper_with_echo_db(input_file, tmp_path):
+#     """
+#     Run the `echo_db` testing algorithm through the wrapper code. The wrapper
+#     communicates through files whose locations are stored in the `INPUT_FILE`,
+#     `TOKEN_FILE` and `DATABASE_URI` environment variables. The output of the
+#     algorithm is stored in the location specified in environment variable
+#     `OUTPUT_FILE`.
+
+#     :param input_file: input arguments to the wrapper and algorithm
+#     :param tmp_path: temporary path to store additional files.
+#     :return:
+#     """
+#     db_file = tmp_path / "db_file.csv"
+#     token_file = tmp_path / "token.txt"
+#     output_file = tmp_path / "output_file.pkl"
+#     db_file.write_text(DATA)
+#     token_file.write_text(TOKEN)
+#     with patch("vantage6.algorithm.tools.docker_wrapper.os") as mock_os:
+#         mock_os.environ = {
+#             "INPUT_FILE": input_file,
+#             "TOKEN_FILE": token_file,
+#             "OUTPUT_FILE": output_file,
+#             "DATABASE_URI": db_file,
+#         }
+
+#         wrapper.docker_wrapper(MODULE_NAME)
+#     return output_file
+
+
+# @patch("vantage6.algorithm.tools.wrap._run_algorithm_method")
+# @patch("vantage6.algorithm.tools.docker_wrapper.os")
+# @patch("vantage6.algorithm.tools.docker_wrapper.SPARQLWrapper")
+# def test_sparql_docker_wrapper_passes_dataframe(
+#     SPARQLWrapper: MagicMock,
+#     os: MagicMock,
+#     _run_algorithm_method: MagicMock,
+#     tmp_path: Path,
+# ):
+#     input_file = tmp_path / "input_file.pkl"
+#     token_file = tmp_path / "token.txt"
+#     output_file = tmp_path / "output.pkl"
+
+#     environ = {
+#         "INPUT_FILE": str(input_file),
+#         "TOKEN_FILE": str(token_file),
+#         "DATABASE_URI": MOCK_SPARQL_ENDPOINT,
+#         "OUTPUT_FILE": str(output_file),
+#     }
+
+#     os.environ = environ
+
+#     input_args = {"query": "select *"}
+
+#     with input_file.open("wb") as f:
+#         json.dumps(input_args, f)
+
+#     with token_file.open("w") as f:
+#         f.write(TOKEN)
+
+#     _run_algorithm_method.return_value = pd.DataFrame()
+#     SPARQLWrapper.return_value.query.return_value.convert.return_value = DATA.encode()
+
+#     wrapper.sparql_wrapper(MODULE_NAME)
+
+#     _run_algorithm_method.assert_called_once()
+
+#     target_df = pd.DataFrame([[1, 2]], columns=["column1", "column2"])
+#     pd.testing.assert_frame_equal(target_df, _run_algorithm_method.call_args[0][0])

vantage6_algorithm_tools-4.13.4/tests/test_serialization.py

@@ -0,0 +1,25 @@
+from pytest import mark
+
+from vantage6.common import serialization
+import pandas as pd
+
+
+@mark.parametrize(
+    "data,target",
+    [
+        # Default serialization
+        ([1, 2, 3], "[1, 2, 3]"),
+        ("hello", '"hello"'),
+        ({"hello": "goodbye"}, '{"hello": "goodbye"}'),
+        # Pandas serialization
+        (
+            pd.DataFrame([[1, 2, 3]], columns=["one", "two", "three"]),
+            '{"one":{"0":1},"two":{"0":2},"three":{"0":3}}',
+        ),
+        (pd.Series([1, 2, 3]), '{"0":1,"1":2,"2":3}'),
+    ],
+)
+def test_json_serialization(data, target):
+    result = serialization.serialize(data)
+
+    assert target == result.decode()

vantage6_algorithm_tools-4.13.4/vantage6/algorithm/client/__build__

@@ -0,0 +1 @@
+0