trainml 0.5.9__py3-none-any.whl → 0.5.12__py3-none-any.whl

tests/integration/projects/conftest.py

@@ -3,6 +3,8 @@ from pytest import fixture
 
 @fixture(scope="module")
 async def project(trainml):
-    project = await trainml.projects.create(name="New Project", copy_keys=False)
+    project = await trainml.projects.create(
+        name="New Project", copy_credentials=False, copy_secrets=False
+    )
     yield project
     await project.remove()

tests/integration/projects/test_projects_credentials_integration.py

@@ -0,0 +1,45 @@
+import re
+import sys
+import asyncio
+from pytest import mark, fixture
+
+pytestmark = [mark.sdk, mark.integration, mark.projects]
+
+
+@mark.create
+@mark.asyncio
+class ProjectCredentialsTests:
+    @fixture(scope="class")
+    async def project_credential(self, project):
+        project_credential = await project.credentials.put(
+            type="aws", key_id="ASFHALKF", secret="IUHKLHKAHF"
+        )
+        yield project_credential
+        await project.credentials.remove(type="aws")
+
+    async def test_list_project_credentials(self, project, project_credential):
+        credentials = await project.credentials.list()
+        assert len(credentials) > 0
+
+    async def test_project_credential_properties(self, project, project_credential):
+        assert isinstance(project_credential.project_uuid, str)
+        assert isinstance(project_credential.type, str)
+        assert isinstance(project_credential.key_id, str)
+        assert project_credential.type == "aws"
+        assert project.id == project_credential.project_uuid
+
+    async def test_project_credential_str(self, project_credential):
+        string = str(project_credential)
+        regex = r"^{.*\"type\": \"" + project_credential.type + r"\".*}$"
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    async def test_project_credential_repr(self, project_credential):
+        string = repr(project_credential)
+        regex = (
+            r"^ProjectCredential\( trainml , \*\*{.*'type': '"
+            + project_credential.type
+            + r"'.*}\)$"
+        )
+        assert isinstance(string, str)
+        assert re.match(regex, string)

tests/integration/projects/test_projects_data_connectors_integration.py

@@ -0,0 +1,44 @@
+import re
+import sys
+import asyncio
+from pytest import mark, fixture
+
+pytestmark = [mark.sdk, mark.integration, mark.projects]
+
+
+@mark.create
+@mark.asyncio
+class ProjectDataConnectorsTests:
+    @fixture(scope="class")
+    async def project_data_connector(self, project):
+        data_connectors = await project.data_connectors.list()
+        yield data_connectors[0]
+
+    async def test_list_project_data_connectors(self, project, project_data_connector):
+        data_connectors = await project.data_connectors.list()
+        assert len(data_connectors) > 0
+
+    async def test_project_data_connector_properties(
+        self, project, project_data_connector
+    ):
+        assert isinstance(project_data_connector.project_uuid, str)
+        assert isinstance(project_data_connector.type, str)
+        assert isinstance(project_data_connector.name, str)
+        assert isinstance(project_data_connector.region_uuid, str)
+        assert project.id == project_data_connector.project_uuid
+
+    async def test_project_data_connector_str(self, project_data_connector):
+        string = str(project_data_connector)
+        regex = r"^{.*\"name\": \"" + project_data_connector.name + r"\".*}$"
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    async def test_project_data_connector_repr(self, project_data_connector):
+        string = repr(project_data_connector)
+        regex = (
+            r"^ProjectDataConnector\( trainml , \*\*{.*'name': '"
+            + project_data_connector.name
+            + r"'.*}\)$"
+        )
+        assert isinstance(string, str)
+        assert re.match(regex, string)

tests/integration/projects/test_projects_datastores_integration.py

@@ -0,0 +1,42 @@
+import re
+import sys
+import asyncio
+from pytest import mark, fixture
+
+pytestmark = [mark.sdk, mark.integration, mark.projects]
+
+
+@mark.create
+@mark.asyncio
+class ProjectDatastoresTests:
+    @fixture(scope="class")
+    async def project_datastore(self, project):
+        datastores = await project.datastores.list()
+        yield datastores[0]
+
+    async def test_list_project_datastores(self, project):
+        datastores = await project.datastores.list()
+        assert len(datastores) > 0
+
+    async def test_project_datastore_properties(self, project, project_datastore):
+        assert isinstance(project_datastore.project_uuid, str)
+        assert isinstance(project_datastore.type, str)
+        assert isinstance(project_datastore.name, str)
+        assert isinstance(project_datastore.region_uuid, str)
+        assert project.id == project_datastore.project_uuid
+
+    async def test_project_datastore_str(self, project_datastore):
+        string = str(project_datastore)
+        regex = r"^{.*\"name\": \"" + project_datastore.name + r"\".*}$"
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    async def test_project_datastore_repr(self, project_datastore):
+        string = repr(project_datastore)
+        regex = (
+            r"^ProjectDatastore\( trainml , \*\*{.*'name': '"
+            + project_datastore.name
+            + r"'.*}\)$"
+        )
+        assert isinstance(string, str)
+        assert re.match(regex, string)

tests/integration/projects/test_projects_secrets_integration.py

@@ -17,7 +17,7 @@ class ProjectSecretsTests:
         yield project_secret
         await project.secrets.remove(name="secret_value")
 
-    async def test_list_project_keys(self, project, project_secret):
+    async def test_list_project_secrets(self, project, project_secret):
         secrets = await project.secrets.list()
         assert len(secrets) > 0
 

tests/integration/projects/test_projects_services_integration.py

@@ -0,0 +1,44 @@
+import re
+import sys
+import asyncio
+from pytest import mark, fixture
+
+pytestmark = [mark.sdk, mark.integration, mark.projects]
+
+
+@mark.create
+@mark.asyncio
+class ProjectServicesTests:
+    @fixture(scope="class")
+    async def project_service(self, project):
+        services = await project.services.list()
+        yield services[0]
+
+    async def test_list_project_services(self, project):
+        services = await project.services.list()
+        assert len(services) > 0
+
+    async def test_project_service_properties(self, project, project_service):
+        assert isinstance(project_service.project_uuid, str)
+        assert isinstance(project_service.name, str)
+        assert isinstance(project_service.id, str)
+        assert isinstance(project_service.hostname, str)
+        assert isinstance(project_service.region_uuid, str)
+        assert isinstance(project_service.public, bool)
+        assert project.id == project_service.project_uuid
+
+    async def test_project_service_str(self, project_service):
+        string = str(project_service)
+        regex = r"^{.*\"name\": \"" + project_service.name + r"\".*}$"
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    async def test_project_service_repr(self, project_service):
+        string = repr(project_service)
+        regex = (
+            r"^ProjectService\( trainml , \*\*{.*'name': '"
+            + project_service.name
+            + r"'.*}\)$"
+        )
+        assert isinstance(string, str)
+        assert re.match(regex, string)

tests/integration/test_checkpoints_integration.py

@@ -16,7 +16,7 @@ class GetCheckpointTests:
             source_type="git",
             source_uri="git@github.com:trainML/environment-tests.git",
         )
-        checkpoint = await checkpoint.wait_for("ready", 120)
+        checkpoint = await checkpoint.wait_for("ready", 180)
         yield checkpoint
         await checkpoint.remove()
         checkpoint = await checkpoint.wait_for("archived", 60)
@@ -59,7 +59,6 @@ async def test_checkpoint_wasabi(trainml, capsys):
         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)

tests/integration/test_models_integration.py

@@ -55,7 +55,6 @@ async def test_model_wasabi(trainml, capsys):
         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)

tests/unit/cli/projects/test_cli_project_credential_unit.py

@@ -0,0 +1,26 @@
+import re
+import json
+import click
+from unittest.mock import AsyncMock, patch, create_autospec
+from pytest import mark, fixture, raises
+
+pytestmark = [mark.cli, mark.unit, mark.projects]
+
+from trainml.cli.project import credential as specimen
+from trainml.projects import (
+    Project,
+)
+
+
+def test_list_credentials(runner, mock_project_credentials):
+    with patch("trainml.cli.TrainML", new=AsyncMock) as mock_trainml:
+        project = create_autospec(Project)
+        mock_trainml.projects = AsyncMock()
+        mock_trainml.projects.get = AsyncMock(return_value=project)
+        mock_trainml.projects.get_current = AsyncMock(return_value=project)
+        project.credentials = AsyncMock()
+        project.credentials.list = AsyncMock(return_value=mock_project_credentials)
+        result = runner.invoke(specimen, ["list"])
+        print(result)
+        assert result.exit_code == 0
+        project.credentials.list.assert_called_once()

tests/unit/cli/projects/test_cli_project_data_connector_unit.py

@@ -0,0 +1,28 @@
+import re
+import json
+import click
+from unittest.mock import AsyncMock, patch, create_autospec
+from pytest import mark, fixture, raises
+
+pytestmark = [mark.cli, mark.unit, mark.projects]
+
+from trainml.cli.project import data_connector as specimen
+from trainml.projects import (
+    Project,
+)
+
+
+def test_list_data_connectors(runner, mock_project_data_connectors):
+    with patch("trainml.cli.TrainML", new=AsyncMock) as mock_trainml:
+        project = create_autospec(Project)
+        mock_trainml.projects = AsyncMock()
+        mock_trainml.projects.get = AsyncMock(return_value=project)
+        mock_trainml.projects.get_current = AsyncMock(return_value=project)
+        project.data_connectors = AsyncMock()
+        project.data_connectors.list = AsyncMock(
+            return_value=mock_project_data_connectors
+        )
+        result = runner.invoke(specimen, ["list"])
+        print(result)
+        assert result.exit_code == 0
+        project.data_connectors.list.assert_called_once()

tests/unit/cli/projects/test_cli_project_datastore_unit.py

@@ -0,0 +1,26 @@
+import re
+import json
+import click
+from unittest.mock import AsyncMock, patch, create_autospec
+from pytest import mark, fixture, raises
+
+pytestmark = [mark.cli, mark.unit, mark.projects]
+
+from trainml.cli.project import datastore as specimen
+from trainml.projects import (
+    Project,
+)
+
+
+def test_list_datastores(runner, mock_project_datastores):
+    with patch("trainml.cli.TrainML", new=AsyncMock) as mock_trainml:
+        project = create_autospec(Project)
+        mock_trainml.projects = AsyncMock()
+        mock_trainml.projects.get = AsyncMock(return_value=project)
+        mock_trainml.projects.get_current = AsyncMock(return_value=project)
+        project.datastores = AsyncMock()
+        project.datastores.list = AsyncMock(return_value=mock_project_datastores)
+        result = runner.invoke(specimen, ["list"])
+        print(result)
+        assert result.exit_code == 0
+        project.datastores.list.assert_called_once()

tests/unit/cli/projects/test_cli_project_key_unit.py

@@ -0,0 +1,26 @@
+import re
+import json
+import click
+from unittest.mock import AsyncMock, patch, create_autospec
+from pytest import mark, fixture, raises
+
+pytestmark = [mark.cli, mark.unit, mark.projects]
+
+from trainml.cli.project import key as specimen
+from trainml.projects import (
+    Project,
+)
+
+
+def test_list_keys(runner, mock_project_keys):
+    with patch("trainml.cli.TrainML", new=AsyncMock) as mock_trainml:
+        project = create_autospec(Project)
+        mock_trainml.projects = AsyncMock()
+        mock_trainml.projects.get = AsyncMock(return_value=project)
+        mock_trainml.projects.get_current = AsyncMock(return_value=project)
+        project.keys = AsyncMock()
+        project.keys.list = AsyncMock(return_value=mock_project_keys)
+        result = runner.invoke(specimen, ["list"])
+        print(result)
+        assert result.exit_code == 0
+        project.keys.list.assert_called_once()

tests/unit/cli/projects/test_cli_project_secret_unit.py

@@ -0,0 +1,26 @@
+import re
+import json
+import click
+from unittest.mock import AsyncMock, patch, create_autospec
+from pytest import mark, fixture, raises
+
+pytestmark = [mark.cli, mark.unit, mark.projects]
+
+from trainml.cli.project import secret as specimen
+from trainml.projects import (
+    Project,
+)
+
+
+def test_list_secrets(runner, mock_project_secrets):
+    with patch("trainml.cli.TrainML", new=AsyncMock) as mock_trainml:
+        project = create_autospec(Project)
+        mock_trainml.projects = AsyncMock()
+        mock_trainml.projects.get = AsyncMock(return_value=project)
+        mock_trainml.projects.get_current = AsyncMock(return_value=project)
+        project.secrets = AsyncMock()
+        project.secrets.list = AsyncMock(return_value=mock_project_secrets)
+        result = runner.invoke(specimen, ["list"])
+        print(result)
+        assert result.exit_code == 0
+        project.secrets.list.assert_called_once()

tests/unit/cli/projects/test_cli_project_service_unit.py

@@ -0,0 +1,26 @@
+import re
+import json
+import click
+from unittest.mock import AsyncMock, patch, create_autospec
+from pytest import mark, fixture, raises
+
+pytestmark = [mark.cli, mark.unit, mark.projects]
+
+from trainml.cli.project import service as specimen
+from trainml.projects import (
+    Project,
+)
+
+
+def test_list_services(runner, mock_project_services):
+    with patch("trainml.cli.TrainML", new=AsyncMock) as mock_trainml:
+        project = create_autospec(Project)
+        mock_trainml.projects = AsyncMock()
+        mock_trainml.projects.get = AsyncMock(return_value=project)
+        mock_trainml.projects.get_current = AsyncMock(return_value=project)
+        project.services = AsyncMock()
+        project.services.list = AsyncMock(return_value=mock_project_services)
+        result = runner.invoke(specimen, ["list"])
+        print(result)
+        assert result.exit_code == 0
+        project.services.list.assert_called_once()

tests/unit/cli/projects/test_cli_project_unit.py

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

tests/unit/cloudbender/test_datastores_unit.py

@@ -119,8 +119,6 @@ class datastoreTests:
         assert isinstance(datastore.region_uuid, str)
         assert isinstance(datastore.type, str)
         assert isinstance(datastore.name, str)
-        assert isinstance(datastore.uri, str)
-        assert isinstance(datastore.root, str)
 
     def test_datastore_str(self, datastore):
         string = str(datastore)
@@ -131,9 +129,7 @@ class datastoreTests:
     def test_datastore_repr(self, datastore):
         string = repr(datastore)
         regex = (
-            r"^Datastore\( trainml , \*\*{.*'store_id': '"
-            + datastore.id
-            + r"'.*}\)$"
+            r"^Datastore\( trainml , \*\*{.*'store_id': '" + datastore.id + r"'.*}\)$"
         )
         assert isinstance(string, str)
         assert re.match(regex, string)

tests/unit/conftest.py

@@ -17,9 +17,11 @@ from trainml.projects import (
     Projects,
     Project,
 )
-from trainml.projects.datastores import ProjectDatastore
-from trainml.projects.services import ProjectService
-from trainml.projects.data_connectors import ProjectDataConnector
+from trainml.projects.datastores import ProjectDatastores, ProjectDatastore
+from trainml.projects.services import ProjectServices, ProjectService
+from trainml.projects.data_connectors import ProjectDataConnectors, ProjectDataConnector
+from trainml.projects.credentials import ProjectCredentials, ProjectCredential
+from trainml.projects.secrets import ProjectSecrets, ProjectSecret
 
 from trainml.cloudbender import Cloudbender
 from trainml.cloudbender.providers import Provider, Providers
@@ -530,7 +532,7 @@ def mock_jobs():
                         {"value": "env1val", "key": "env1"},
                         {"value": "env2val", "key": "env2"},
                     ],
-                    "worker_key_types": ["aws", "gcp"],
+                    "credentials": ["aws", "gcp"],
                     "status": "new",
                 },
                 "vpn": {
@@ -607,7 +609,7 @@ def mock_jobs():
                     "type": "DEEPLEARNING_PY37",
                     "image_size": 39656398629,
                     "env": [],
-                    "worker_key_types": [],
+                    "credentials": [],
                     "status": "ready",
                 },
                 "vpn": {
@@ -1038,6 +1040,60 @@ def mock_device_configs():
     ]
 
 
+@fixture(
+    scope="session",
+)
+def mock_project_credentials():
+    trainml = Mock()
+    yield [
+        ProjectCredential(
+            trainml,
+            **{
+                "project_uuid": "proj-id-1",
+                "type": "aws",
+                "key_id": "AKSHFKHDFS",
+                "updatedAt": "2023-06-02T21:22:40.084Z",
+            },
+        ),
+        ProjectCredential(
+            trainml,
+            **{
+                "project_uuid": "proj-id-1",
+                "type": "gcp",
+                "key_id": "credentials.json",
+                "updatedAt": "2023-06-02T21:22:40.084Z",
+            },
+        ),
+    ]
+
+
+@fixture(
+    scope="session",
+)
+def mock_project_secrets():
+    trainml = Mock()
+    yield [
+        ProjectSecret(
+            trainml,
+            **{
+                "project_uuid": "proj-id-1",
+                "name": "super_secret",
+                "created_by": "User",
+                "updatedAt": "2023-06-02T21:22:40.084Z",
+            },
+        ),
+        ProjectSecret(
+            trainml,
+            **{
+                "project_uuid": "proj-id-1",
+                "name": "super_secret_2",
+                "created_by": "User",
+                "updatedAt": "2023-06-02T21:22:40.084Z",
+            },
+        ),
+    ]
+
+
 @fixture(scope="function")
 def mock_trainml(
     mock_my_datasets,
@@ -1058,6 +1114,11 @@ def mock_trainml(
     mock_services,
     mock_data_connectors,
     mock_device_configs,
+    mock_project_datastores,
+    mock_project_services,
+    mock_project_data_connectors,
+    mock_project_credentials,
+    mock_project_secrets,
 ):
     trainml = create_autospec(TrainML)
     trainml.active_project = "proj-id-1"
@@ -1081,6 +1142,18 @@ def mock_trainml(
     trainml.environments.list = AsyncMock(return_value=mock_environments)
     trainml.jobs.list = AsyncMock(return_value=mock_jobs)
     trainml.projects.list = AsyncMock(return_value=mock_projects)
+    trainml.projects.datastores = create_autospec(ProjectDatastores)
+    trainml.projects.datastores.list = AsyncMock(return_value=mock_project_datastores)
+    trainml.projects.services = create_autospec(ProjectServices)
+    trainml.projects.services.list = AsyncMock(return_value=mock_project_services)
+    trainml.projects.data_connectors = create_autospec(ProjectDataConnectors)
+    trainml.projects.data_connectors.list = AsyncMock(
+        return_value=mock_project_data_connectors
+    )
+    trainml.projects.credentials = create_autospec(ProjectCredentials)
+    trainml.projects.credentials.list = AsyncMock(return_value=mock_project_credentials)
+    trainml.projects.secrets = create_autospec(ProjectSecrets)
+    trainml.projects.secrets.list = AsyncMock(return_value=mock_project_secrets)
 
     trainml.cloudbender = create_autospec(Cloudbender)
 
@@ -1090,7 +1163,7 @@ def mock_trainml(
     trainml.cloudbender.regions.list = AsyncMock(return_value=mock_regions)
     trainml.cloudbender.nodes = create_autospec(Nodes)
     trainml.cloudbender.nodes.list = AsyncMock(return_value=mock_nodes)
-    trainml.cloudbender.devices = create_autospec(Nodes)
+    trainml.cloudbender.devices = create_autospec(Devices)
     trainml.cloudbender.devices.list = AsyncMock(return_value=mock_devices)
     trainml.cloudbender.datastores = create_autospec(Datastores)
     trainml.cloudbender.datastores.list = AsyncMock(return_value=mock_datastores)

tests/unit/projects/test_project_credentials_unit.py

@@ -0,0 +1,100 @@
+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.projects.credentials as specimen
+from trainml.exceptions import (
+    ApiError,
+    SpecificationError,
+    TrainMLException,
+)
+
+pytestmark = [mark.sdk, mark.unit, mark.projects]
+
+
+@fixture
+def project_credentials(mock_trainml):
+    yield specimen.ProjectCredentials(mock_trainml, project_id="1")
+
+
+@fixture
+def project_credential(mock_trainml):
+    yield specimen.ProjectCredential(
+        mock_trainml, project_uuid="proj-id-1", type="aws", key_id="AIYHGFSDLK"
+    )
+
+
+class ProjectCredentialsTests:
+    @mark.asyncio
+    async def test_project_credentials_list(self, project_credentials, mock_trainml):
+        api_response = [
+            {"project_uuid": "proj-id-1", "type": "aws", "key_id": "AIYHGFSDLK"},
+            {"project_uuid": "proj-id-1", "type": "gcp", "key_id": "credentials.json"},
+        ]
+        mock_trainml._query = AsyncMock(return_value=api_response)
+        resp = await project_credentials.list()
+        mock_trainml._query.assert_called_once_with(
+            "/project/1/credentials", "GET", dict()
+        )
+        assert len(resp) == 2
+
+    @mark.asyncio
+    async def test_remove_project_credential(
+        self,
+        project_credentials,
+        mock_trainml,
+    ):
+        api_response = dict()
+        mock_trainml._query = AsyncMock(return_value=api_response)
+        await project_credentials.remove("aws")
+        mock_trainml._query.assert_called_once_with(
+            "/project/1/credential/aws", "DELETE", dict()
+        )
+
+    @mark.asyncio
+    async def test_put_project_credential(self, project_credentials, mock_trainml):
+        requested_config = dict(type="aws", key_id="AIUDHADA", secret="ASKHJSLKF")
+        expected_payload = dict(key_id="AIUDHADA", secret="ASKHJSLKF")
+        api_response = {
+            "project_uuid": "project-id-1",
+            "type": "aws",
+            "key_id": "AIUDHADA",
+        }
+
+        mock_trainml._query = AsyncMock(return_value=api_response)
+        response = await project_credentials.put(**requested_config)
+        mock_trainml._query.assert_called_once_with(
+            "/project/1/credential/aws", "PUT", None, expected_payload
+        )
+        assert response.type == "aws"
+
+
+class ProjectCredentialTests:
+    def test_project_credential_properties(self, project_credential):
+        assert isinstance(project_credential.type, str)
+        assert isinstance(project_credential.key_id, str)
+        assert isinstance(project_credential.project_uuid, str)
+
+    def test_project_credential_str(self, project_credential):
+        string = str(project_credential)
+        regex = r"^{.*\"type\": \"" + project_credential.type + r"\".*}$"
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    def test_project_credential_repr(self, project_credential):
+        string = repr(project_credential)
+        regex = (
+            r"^ProjectCredential\( trainml , \*\*{.*'type': '"
+            + project_credential.type
+            + r"'.*}\)$"
+        )
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    def test_project_credential_bool(self, project_credential, mock_trainml):
+        empty_project_credential = specimen.ProjectCredential(mock_trainml)
+        assert bool(project_credential)
+        assert not bool(empty_project_credential)