trainml 0.5.4__tar.gz → 0.5.6__tar.gz

{trainml-0.5.4/trainml.egg-info → trainml-0.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: trainml
-Version: 0.5.4
+Version: 0.5.6
 Summary: trainML client SDK and command line utilities
 Home-page: https://github.com/trainML/trainml-cli
 Author: trainML

{trainml-0.5.4 → trainml-0.5.6}/pyproject.toml

@@ -3,9 +3,7 @@ python_files = "test_*"
 python_classes = "*Tests"
 python_functions = "test_*"
 asyncio_mode = "auto"
-testpaths = [
-    "tests",
-]
+testpaths = ["tests"]
 markers = [
     "create: Tests that create resources on the trainml platform",
     "gpu_types: Gpu Type tests",
@@ -13,6 +11,7 @@ markers = [
     "datasets: Datasets tests",
     "models: Models tests",
     "checkpoints: Checkpoints tests",
+    "volumes: Volumes tests",
     "jobs: Jobs tests",
     "connections: Connections tests",
     "projects: Projects tests",
@@ -22,10 +21,10 @@ markers = [
     "nodes: Nodes tests",
     "devices: Devices tests",
     "datastores: Datastores tests",
-    "reservations: Reservations tests",
+    "services: Services tests",
     "device_configs: DeviceConfigs tests",
     "unit: All unit tests (no trainML environment required)",
     "integration: All integration tests (trainML environment required)",
     "sdk: All tests of the SDK",
-    "cli: All test of the cli"
-]
+    "cli: All test of the cli",
+]

{trainml-0.5.4 → trainml-0.5.6}/tests/integration/test_checkpoints_integration.py

@@ -54,18 +54,20 @@ class GetCheckpointTests:
 
 @mark.create
 @mark.asyncio
-async def test_checkpoint_aws(trainml, capsys):
+async def test_checkpoint_wasabi(trainml, capsys):
     checkpoint = await trainml.checkpoints.create(
-        name="CLI Automated AWS",
-        source_type="aws",
-        source_uri="s3://trainml-examples/models/mxnet-model.zip",
+        name="CLI Automated Wasabi",
+        source_type="wasabi",
+        source_uri="s3://trainml-example/models/trainml-examples",
+        capacity="10G",
+        source_options=dict(endpoint_url="https://s3.wasabisys.com"),
     )
     checkpoint = await checkpoint.wait_for("ready", 300)
     status = checkpoint.status
     size = checkpoint.size
     await checkpoint.remove()
     assert status == "ready"
-    assert size >= 1000000
+    assert size >= 500000
 
 
 @mark.create

{trainml-0.5.4 → trainml-0.5.6}/tests/integration/test_datasets_integration.py

@@ -13,8 +13,9 @@ class GetDatasetTests:
     async def dataset(self, trainml):
         dataset = await trainml.datasets.create(
             name="CLI Automated",
-            source_type="aws",
-            source_uri="s3://trainml-examples/data/cifar10",
+            source_type="wasabi",
+            source_uri="s3://trainml-example/input/cifar-10/cifar-10-batches-bin",
+            source_options=dict(endpoint_url="https://s3.wasabisys.com"),
         )
         dataset = await dataset.wait_for("ready", 300)
         yield dataset
@@ -48,9 +49,7 @@ class GetDatasetTests:
     async def test_dataset_repr(self, dataset):
         string = repr(dataset)
         regex = (
-            r"^Dataset\( trainml , \*\*{.*'dataset_uuid': '"
-            + dataset.id
-            + r"'.*}\)$"
+            r"^Dataset\( trainml , \*\*{.*'dataset_uuid': '" + dataset.id + r"'.*}\)$"
         )
         assert isinstance(string, str)
         assert re.match(regex, string)

{trainml-0.5.4 → trainml-0.5.6}/tests/integration/test_jobs_integration.py

@@ -269,7 +269,7 @@ class JobAPIDataValidationTests:
                 ),
             )
         assert (
-            "Invalid Request - Only regional datastore are allowed for Notebook and Endpoint output locations"
+            "Invalid Request - output_type invalid for Notebook and Endpoint jobs"
             in error.value.message
         )
 
@@ -298,7 +298,45 @@ class JobAPIDataValidationTests:
                 ),
             )
         assert (
-            "Invalid Request - Only regional datastore are allowed for Notebook and Endpoint output locations"
+            "Invalid Request - output_type invalid for Notebook and Endpoint jobs"
+            in error.value.message
+        )
+
+    async def test_invalid_volumes_for_training(self, trainml):
+        with raises(ApiError) as error:
+            await trainml.jobs.create(
+                name="Invalid Volumes for Training",
+                type="training",
+                gpu_types=["rtx3090"],
+                disk_size=10,
+                data=dict(
+                    output_uri="s3://trainml-examples/output/resnet_cifar10",
+                    output_type="aws",
+                    volumes=["volume-id"],
+                ),
+                workers=["python train.py"],
+            )
+        assert (
+            "Invalid Request - Only Notebook and Endpoint job types can use writable volumes"
+            in error.value.message
+        )
+
+    async def test_invalid_volumes_for_inference(self, trainml):
+        with raises(ApiError) as error:
+            await trainml.jobs.create(
+                name="Invalid Volumes for Inference",
+                type="inference",
+                gpu_types=["rtx3090"],
+                disk_size=10,
+                data=dict(
+                    output_uri="s3://trainml-examples/output/resnet_cifar10",
+                    output_type="aws",
+                    volumes=["volume-id"],
+                ),
+                workers=["python predict.py"],
+            )
+        assert (
+            "Invalid Request - Only Notebook and Endpoint job types can use writable volumes"
             in error.value.message
         )
 

{trainml-0.5.4 → trainml-0.5.6}/tests/integration/test_models_integration.py

@@ -43,29 +43,27 @@ class GetModelTests:
 
     async def test_model_repr(self, model):
         string = repr(model)
-        regex = (
-            r"^Model\( trainml , \*\*{.*'model_uuid': '"
-            + model.id
-            + r"'.*}\)$"
-        )
+        regex = r"^Model\( trainml , \*\*{.*'model_uuid': '" + model.id + r"'.*}\)$"
         assert isinstance(string, str)
         assert re.match(regex, string)
 
 
 @mark.create
 @mark.asyncio
-async def test_model_aws(trainml, capsys):
+async def test_model_wasabi(trainml, capsys):
     model = await trainml.models.create(
-        name="CLI Automated AWS",
-        source_type="aws",
-        source_uri="s3://trainml-examples/models/mxnet-model.zip",
+        name="CLI Automated Wasabi",
+        source_type="wasabi",
+        source_uri="s3://trainml-example/models/trainml-examples",
+        capacity="10G",
+        source_options=dict(endpoint_url="https://s3.wasabisys.com"),
     )
     model = await model.wait_for("ready", 300)
     status = model.status
     size = model.size
     await model.remove()
     assert status == "ready"
-    assert size >= 1000000
+    assert size >= 500000
 
 
 @mark.create

{trainml-0.5.4 → trainml-0.5.6}/tests/integration/test_projects_integration.py

@@ -11,9 +11,7 @@ pytestmark = [mark.sdk, mark.integration, mark.projects]
 class GetProjectsTests:
     @fixture(scope="class")
     async def project(self, trainml):
-        project = await trainml.projects.create(
-            name="New Project", copy_keys=False
-        )
+        project = await trainml.projects.create(name="New Project", copy_keys=False)
         yield project
         await project.remove()
 
@@ -41,8 +39,6 @@ class GetProjectsTests:
 
     async def test_project_repr(self, project):
         string = repr(project)
-        regex = (
-            r"^Project\( trainml , \*\*{.*'id': '" + project.id + r"'.*}\)$"
-        )
+        regex = r"^Project\( trainml , \*\*{.*'id': '" + project.id + r"'.*}\)$"
         assert isinstance(string, str)
         assert re.match(regex, string)

trainml-0.5.6/tests/integration/test_volumes_integration.py

@@ -0,0 +1,100 @@
+import re
+import sys
+import asyncio
+from pytest import mark, fixture
+
+pytestmark = [mark.sdk, mark.integration, mark.volumes]
+
+
+@mark.create
+@mark.asyncio
+class GetVolumeTests:
+    @fixture(scope="class")
+    async def volume(self, trainml):
+        volume = await trainml.volumes.create(
+            name="CLI Automated",
+            source_type="git",
+            source_uri="git@github.com:trainML/environment-tests.git",
+            capacity="10G",
+        )
+        volume = await volume.wait_for("ready", 120)
+        yield volume
+        await volume.remove()
+        volume = await volume.wait_for("archived", 60)
+
+    async def test_get_volumes(self, trainml, volume):
+        volumes = await trainml.volumes.list()
+        assert len(volumes) > 0
+
+    async def test_get_volume(self, trainml, volume):
+        response = await trainml.volumes.get(volume.id)
+        assert response.id == volume.id
+
+    async def test_volume_properties(self, volume):
+        assert isinstance(volume.id, str)
+        assert isinstance(volume.status, str)
+        assert isinstance(volume.name, str)
+        assert isinstance(volume.capacity, str)
+        assert isinstance(volume.used_size, int)
+        assert isinstance(volume.billed_size, int)
+
+    async def test_volume_str(self, volume):
+        string = str(volume)
+        regex = r"^{.*\"id\": \"" + volume.id + r"\".*}$"
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    async def test_volume_repr(self, volume):
+        string = repr(volume)
+        regex = r"^Volume\( trainml , \*\*{.*'id': '" + volume.id + r"'.*}\)$"
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+
+@mark.create
+@mark.asyncio
+async def test_volume_wasabi(trainml, capsys):
+    volume = await trainml.volumes.create(
+        name="CLI Automated Wasabi",
+        source_type="wasabi",
+        source_uri="s3://trainml-example/models/trainml-examples",
+        capacity="10G",
+        source_options=dict(endpoint_url="https://s3.wasabisys.com"),
+    )
+    volume = await volume.wait_for("ready", 300)
+    status = volume.status
+    billed_size = volume.billed_size
+    used_size = volume.used_size
+    await volume.remove()
+    assert status == "ready"
+    assert billed_size >= 10000000
+    assert used_size >= 500000
+
+
+@mark.create
+@mark.asyncio
+async def test_volume_local(trainml, capsys):
+    volume = await trainml.volumes.create(
+        name="CLI Automated Local",
+        source_type="local",
+        source_uri="~/tensorflow-model",
+        capacity="10G",
+    )
+    attach_task = asyncio.create_task(volume.attach())
+    connect_task = asyncio.create_task(volume.connect())
+    await asyncio.gather(attach_task, connect_task)
+    await volume.disconnect()
+    await volume.refresh()
+    status = volume.status
+    billed_size = volume.billed_size
+    used_size = volume.used_size
+    await volume.remove()
+    assert status == "ready"
+    assert billed_size >= 10000000
+    assert used_size >= 1000000
+    captured = capsys.readouterr()
+    sys.stdout.write(captured.out)
+    sys.stderr.write(captured.err)
+    assert "Starting data upload from local" in captured.out
+    assert "official/LICENSE  11456 bytes" in captured.out
+    assert "Upload complete" in captured.out

trainml-0.5.6/tests/unit/cli/cloudbender/test_cli_reservation_unit.py

@@ -0,0 +1,34 @@
+import re
+import json
+import click
+from unittest.mock import AsyncMock, patch
+from pytest import mark, fixture, raises
+
+pytestmark = [mark.cli, mark.unit, mark.cloudbender, mark.services]
+
+from trainml.cli.cloudbender import service as specimen
+from trainml.cloudbender.services import Service
+
+
+def test_list(runner, mock_services):
+    with patch("trainml.cli.TrainML", new=AsyncMock) as mock_trainml:
+        mock_trainml.cloudbender = AsyncMock()
+        mock_trainml.cloudbender.services = AsyncMock()
+        mock_trainml.cloudbender.services.list = AsyncMock(return_value=mock_services)
+        result = runner.invoke(
+            specimen,
+            args=["list", "--provider=prov-id-1", "--region=reg-id-1"],
+        )
+        assert result.exit_code == 0
+        mock_trainml.cloudbender.services.list.assert_called_once_with(
+            provider_uuid="prov-id-1", region_uuid="reg-id-1"
+        )
+
+
+def test_list_no_provider(runner, mock_services):
+    with patch("trainml.cli.TrainML", new=AsyncMock) as mock_trainml:
+        mock_trainml.cloudbender = AsyncMock()
+        mock_trainml.cloudbender.services = AsyncMock()
+        mock_trainml.cloudbender.services.list = AsyncMock(return_value=mock_services)
+        result = runner.invoke(specimen, ["list"])
+        assert result.exit_code != 0

{trainml-0.5.4 → trainml-0.5.6}/tests/unit/cli/test_cli_project_unit.py

@@ -23,9 +23,7 @@ def test_list(runner, mock_projects):
 def test_list_datastores(runner, mock_project_datastores):
     with patch("trainml.cli.TrainML", new=AsyncMock) as mock_trainml:
         mock_project = create_autospec(Project)
-        mock_project.list_datastores = AsyncMock(
-            return_value=mock_project_datastores
-        )
+        mock_project.list_datastores = AsyncMock(return_value=mock_project_datastores)
         mock_trainml.projects.get = AsyncMock(return_value=mock_project)
         result = runner.invoke(specimen, ["list-datastores"])
         print(result)
@@ -33,14 +31,12 @@ def test_list_datastores(runner, mock_project_datastores):
         mock_project.list_datastores.assert_called_once()
 
 
-def test_list_reservations(runner, mock_project_reservations):
+def test_list_services(runner, mock_project_services):
     with patch("trainml.cli.TrainML", new=AsyncMock) as mock_trainml:
         mock_project = create_autospec(Project)
-        mock_project.list_reservations = AsyncMock(
-            return_value=mock_project_reservations
-        )
+        mock_project.list_services = AsyncMock(return_value=mock_project_services)
         mock_trainml.projects.get = AsyncMock(return_value=mock_project)
-        result = runner.invoke(specimen, ["list-reservations"])
+        result = runner.invoke(specimen, ["list-services"])
         print(result)
         assert result.exit_code == 0
-        mock_project.list_reservations.assert_called_once()
+        mock_project.list_services.assert_called_once()

trainml-0.5.6/tests/unit/cli/test_cli_volume_unit.py

@@ -0,0 +1,20 @@
+import re
+import json
+import click
+from unittest.mock import AsyncMock, patch
+from pytest import mark, fixture, raises
+
+pytestmark = [mark.cli, mark.unit, mark.volumes]
+
+from trainml.cli import volume as specimen
+from trainml.volumes import Volume
+
+
+def test_list(runner, mock_my_volumes):
+    with patch("trainml.cli.TrainML", new=AsyncMock) as mock_trainml:
+        mock_trainml.volumes = AsyncMock()
+        mock_trainml.volumes.list = AsyncMock(return_value=mock_my_volumes)
+        result = runner.invoke(specimen, ["list"])
+        print(result)
+        assert result.exit_code == 0
+        mock_trainml.volumes.list.assert_called_once()

trainml-0.5.6/tests/unit/cloudbender/test_services_unit.py

@@ -0,0 +1,161 @@
+import re
+import json
+import logging
+from unittest.mock import AsyncMock, patch
+from pytest import mark, fixture, raises
+from aiohttp import WSMessage, WSMsgType
+
+import trainml.cloudbender.services as specimen
+from trainml.exceptions import (
+    ApiError,
+    SpecificationError,
+    TrainMLException,
+)
+
+pytestmark = [mark.sdk, mark.unit, mark.cloudbender, mark.services]
+
+
+@fixture
+def services(mock_trainml):
+    yield specimen.Services(mock_trainml)
+
+
+@fixture
+def service(mock_trainml):
+    yield specimen.Service(
+        mock_trainml,
+        provider_uuid="1",
+        region_uuid="a",
+        service_id="x",
+        name="On-Prem Service",
+        public=False,
+        hostname="app1.proximl.cloud",
+    )
+
+
+class RegionsTests:
+    @mark.asyncio
+    async def test_get_service(
+        self,
+        services,
+        mock_trainml,
+    ):
+        api_response = dict()
+        mock_trainml._query = AsyncMock(return_value=api_response)
+        await services.get("1234", "5687", "91011")
+        mock_trainml._query.assert_called_once_with(
+            "/provider/1234/region/5687/service/91011", "GET", {}
+        )
+
+    @mark.asyncio
+    async def test_list_services(
+        self,
+        services,
+        mock_trainml,
+    ):
+        api_response = dict()
+        mock_trainml._query = AsyncMock(return_value=api_response)
+        await services.list("1234", "5687")
+        mock_trainml._query.assert_called_once_with(
+            "/provider/1234/region/5687/service", "GET", {}
+        )
+
+    @mark.asyncio
+    async def test_remove_service(
+        self,
+        services,
+        mock_trainml,
+    ):
+        api_response = dict()
+        mock_trainml._query = AsyncMock(return_value=api_response)
+        await services.remove("1234", "4567", "8910")
+        mock_trainml._query.assert_called_once_with(
+            "/provider/1234/region/4567/service/8910", "DELETE", {}
+        )
+
+    @mark.asyncio
+    async def test_create_service(self, services, mock_trainml):
+        requested_config = dict(
+            provider_uuid="provider-id-1",
+            region_uuid="region-id-1",
+            name="On-Prem Service",
+            public=False,
+        )
+        expected_payload = dict(
+            name="On-Prem Service",
+            public=False,
+        )
+        api_response = {
+            "provider_uuid": "provider-id-1",
+            "region_uuid": "region-id-1",
+            "service_id": "service-id-1",
+            "name": "On-Prem Service",
+            "public": False,
+            "hostname": "app1.proximl.cloud",
+            "createdAt": "2020-12-31T23:59:59.000Z",
+        }
+
+        mock_trainml._query = AsyncMock(return_value=api_response)
+        response = await services.create(**requested_config)
+        mock_trainml._query.assert_called_once_with(
+            "/provider/provider-id-1/region/region-id-1/service",
+            "POST",
+            None,
+            expected_payload,
+        )
+        assert response.id == "service-id-1"
+
+
+class serviceTests:
+    def test_service_properties(self, service):
+        assert isinstance(service.id, str)
+        assert isinstance(service.provider_uuid, str)
+        assert isinstance(service.region_uuid, str)
+        assert isinstance(service.public, bool)
+        assert isinstance(service.name, str)
+        assert isinstance(service.hostname, str)
+
+    def test_service_str(self, service):
+        string = str(service)
+        regex = r"^{.*\"service_id\": \"" + service.id + r"\".*}$"
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    def test_service_repr(self, service):
+        string = repr(service)
+        regex = r"^Service\( trainml , \*\*{.*'service_id': '" + service.id + r"'.*}\)$"
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    def test_service_bool(self, service, mock_trainml):
+        empty_service = specimen.Service(mock_trainml)
+        assert bool(service)
+        assert not bool(empty_service)
+
+    @mark.asyncio
+    async def test_service_remove(self, service, mock_trainml):
+        api_response = dict()
+        mock_trainml._query = AsyncMock(return_value=api_response)
+        await service.remove()
+        mock_trainml._query.assert_called_once_with(
+            "/provider/1/region/a/service/x", "DELETE"
+        )
+
+    @mark.asyncio
+    async def test_service_refresh(self, service, mock_trainml):
+        api_response = {
+            "provider_uuid": "provider-id-1",
+            "region_uuid": "region-id-1",
+            "service_id": "service-id-1",
+            "name": "On-Prem Service",
+            "public": False,
+            "hostname": "app1.proximl.cloud",
+            "createdAt": "2020-12-31T23:59:59.000Z",
+        }
+        mock_trainml._query = AsyncMock(return_value=api_response)
+        response = await service.refresh()
+        mock_trainml._query.assert_called_once_with(
+            f"/provider/1/region/a/service/x", "GET"
+        )
+        assert service.id == "service-id-1"
+        assert response.id == "service-id-1"