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

tests/unit/cloudbender/test_reservations_unit.py

@@ -1,173 +0,0 @@
-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.reservations as specimen
-from trainml.exceptions import (
-    ApiError,
-    SpecificationError,
-    TrainMLException,
-)
-
-pytestmark = [mark.sdk, mark.unit, mark.cloudbender, mark.reservations]
-
-
-@fixture
-def reservations(mock_trainml):
-    yield specimen.Reservations(mock_trainml)
-
-
-@fixture
-def reservation(mock_trainml):
-    yield specimen.Reservation(
-        mock_trainml,
-        provider_uuid="1",
-        region_uuid="a",
-        reservation_id="x",
-        name="On-Prem Reservation",
-        type="port",
-        resource="8001",
-        hostname="service.local",
-    )
-
-
-class RegionsTests:
-    @mark.asyncio
-    async def test_get_reservation(
-        self,
-        reservations,
-        mock_trainml,
-    ):
-        api_response = dict()
-        mock_trainml._query = AsyncMock(return_value=api_response)
-        await reservations.get("1234", "5687", "91011")
-        mock_trainml._query.assert_called_once_with(
-            "/provider/1234/region/5687/reservation/91011", "GET", {}
-        )
-
-    @mark.asyncio
-    async def test_list_reservations(
-        self,
-        reservations,
-        mock_trainml,
-    ):
-        api_response = dict()
-        mock_trainml._query = AsyncMock(return_value=api_response)
-        await reservations.list("1234", "5687")
-        mock_trainml._query.assert_called_once_with(
-            "/provider/1234/region/5687/reservation", "GET", {}
-        )
-
-    @mark.asyncio
-    async def test_remove_reservation(
-        self,
-        reservations,
-        mock_trainml,
-    ):
-        api_response = dict()
-        mock_trainml._query = AsyncMock(return_value=api_response)
-        await reservations.remove("1234", "4567", "8910")
-        mock_trainml._query.assert_called_once_with(
-            "/provider/1234/region/4567/reservation/8910", "DELETE", {}
-        )
-
-    @mark.asyncio
-    async def test_create_reservation(self, reservations, mock_trainml):
-        requested_config = dict(
-            provider_uuid="provider-id-1",
-            region_uuid="region-id-1",
-            name="On-Prem Reservation",
-            type="port",
-            resource="8001",
-            hostname="service.local",
-        )
-        expected_payload = dict(
-            name="On-Prem Reservation",
-            type="port",
-            resource="8001",
-            hostname="service.local",
-        )
-        api_response = {
-            "provider_uuid": "provider-id-1",
-            "region_uuid": "region-id-1",
-            "reservation_id": "reservation-id-1",
-            "name": "On-Prem Reservation",
-            "type": "port",
-            "resource": "8001",
-            "hostname": "service.local",
-            "createdAt": "2020-12-31T23:59:59.000Z",
-        }
-
-        mock_trainml._query = AsyncMock(return_value=api_response)
-        response = await reservations.create(**requested_config)
-        mock_trainml._query.assert_called_once_with(
-            "/provider/provider-id-1/region/region-id-1/reservation",
-            "POST",
-            None,
-            expected_payload,
-        )
-        assert response.id == "reservation-id-1"
-
-
-class reservationTests:
-    def test_reservation_properties(self, reservation):
-        assert isinstance(reservation.id, str)
-        assert isinstance(reservation.provider_uuid, str)
-        assert isinstance(reservation.region_uuid, str)
-        assert isinstance(reservation.type, str)
-        assert isinstance(reservation.name, str)
-        assert isinstance(reservation.resource, str)
-        assert isinstance(reservation.hostname, str)
-
-    def test_reservation_str(self, reservation):
-        string = str(reservation)
-        regex = r"^{.*\"reservation_id\": \"" + reservation.id + r"\".*}$"
-        assert isinstance(string, str)
-        assert re.match(regex, string)
-
-    def test_reservation_repr(self, reservation):
-        string = repr(reservation)
-        regex = (
-            r"^Reservation\( trainml , \*\*{.*'reservation_id': '"
-            + reservation.id
-            + r"'.*}\)$"
-        )
-        assert isinstance(string, str)
-        assert re.match(regex, string)
-
-    def test_reservation_bool(self, reservation, mock_trainml):
-        empty_reservation = specimen.Reservation(mock_trainml)
-        assert bool(reservation)
-        assert not bool(empty_reservation)
-
-    @mark.asyncio
-    async def test_reservation_remove(self, reservation, mock_trainml):
-        api_response = dict()
-        mock_trainml._query = AsyncMock(return_value=api_response)
-        await reservation.remove()
-        mock_trainml._query.assert_called_once_with(
-            "/provider/1/region/a/reservation/x", "DELETE"
-        )
-
-    @mark.asyncio
-    async def test_reservation_refresh(self, reservation, mock_trainml):
-        api_response = {
-            "provider_uuid": "provider-id-1",
-            "region_uuid": "region-id-1",
-            "reservation_id": "reservation-id-1",
-            "name": "On-Prem Reservation",
-            "type": "port",
-            "resource": "8001",
-            "hostname": "service.local",
-            "createdAt": "2020-12-31T23:59:59.000Z",
-        }
-        mock_trainml._query = AsyncMock(return_value=api_response)
-        response = await reservation.refresh()
-        mock_trainml._query.assert_called_once_with(
-            f"/provider/1/region/a/reservation/x", "GET"
-        )
-        assert reservation.id == "reservation-id-1"
-        assert response.id == "reservation-id-1"

tests/unit/test_auth.py

@@ -1,30 +0,0 @@
-import re
-import logging
-import json
-import os
-from unittest.mock import AsyncMock, patch, mock_open, MagicMock
-from pytest import mark, fixture, raises
-from aiohttp import WSMessage, WSMsgType
-
-import trainml.auth as specimen
-
-pytestmark = [mark.sdk, mark.unit]
-
-
-@patch.dict(
-    os.environ,
-    {
-        "TRAINML_USER": "user-id",
-        "TRAINML_KEY": "key",
-        "TRAINML_REGION": "ap-east-1",
-        "TRAINML_CLIENT_ID": "client_id",
-        "TRAINML_POOL_ID": "pool_id",
-    },
-)
-def test_auth_from_envs():
-    auth = specimen.Auth(config_dir=os.path.expanduser("~/.trainml"))
-    assert auth.__dict__.get("username") == "user-id"
-    assert auth.__dict__.get("password") == "key"
-    assert auth.__dict__.get("region") == "ap-east-1"
-    assert auth.__dict__.get("client_id") == "client_id"
-    assert auth.__dict__.get("pool_id") == "pool_id"

tests/unit/test_projects_unit.py

@@ -1,320 +0,0 @@
-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 as specimen
-from trainml.exceptions import (
-    ApiError,
-    SpecificationError,
-    TrainMLException,
-)
-
-pytestmark = [mark.sdk, mark.unit, mark.projects]
-
-
-@fixture
-def projects(mock_trainml):
-    yield specimen.Projects(mock_trainml)
-
-
-@fixture
-def project(mock_trainml):
-    yield specimen.Project(
-        mock_trainml,
-        id="1",
-        name="My Mock Project",
-        owner=True,
-        owner_name="Me",
-        created_name="Me",
-        job_all=True,
-        dataset_all=True,
-        model_all=True,
-        createdAt="2020-12-31T23:59:59.000Z",
-    )
-
-
-@fixture
-def project_datastore(mock_trainml):
-    yield specimen.ProjectDatastore(
-        mock_trainml,
-        id="ds-id-1",
-        name="datastore 1",
-        project_uuid="proj-id-1",
-        type="nfs",
-        region_uuid="reg-id-1",
-    )
-
-
-@fixture
-def project_data_connector(mock_trainml):
-    yield specimen.ProjectDataConnector(
-        mock_trainml,
-        id="ds-id-1",
-        name="connector 1",
-        project_uuid="proj-id-1",
-        type="custom",
-        region_uuid="reg-id-1",
-    )
-
-
-@fixture
-def project_service(mock_trainml):
-    yield specimen.ProjectService(
-        mock_trainml,
-        id="res-id-1",
-        name="service 1",
-        project_uuid="proj-id-1",
-        region_uuid="reg-id-1",
-        public=False,
-        hostname="asdf.proximl.cloud",
-    )
-
-
-class ProjectsTests:
-    @mark.asyncio
-    async def test_get_project(
-        self,
-        projects,
-        mock_trainml,
-    ):
-        api_response = dict()
-        mock_trainml._query = AsyncMock(return_value=api_response)
-        await projects.get("1234")
-        mock_trainml._query.assert_called_once_with("/project/1234", "GET", dict())
-
-    @mark.asyncio
-    async def test_list_projects(
-        self,
-        projects,
-        mock_trainml,
-    ):
-        api_response = dict()
-        mock_trainml._query = AsyncMock(return_value=api_response)
-        await projects.list()
-        mock_trainml._query.assert_called_once_with("/project", "GET", dict())
-
-    @mark.asyncio
-    async def test_remove_project(
-        self,
-        projects,
-        mock_trainml,
-    ):
-        api_response = dict()
-        mock_trainml._query = AsyncMock(return_value=api_response)
-        await projects.remove("4567")
-        mock_trainml._query.assert_called_once_with("/project/4567", "DELETE", dict())
-
-    @mark.asyncio
-    async def test_create_project_simple(self, projects, mock_trainml):
-        requested_config = dict(
-            name="new project",
-        )
-        expected_payload = dict(name="new project", copy_keys=False)
-        api_response = {
-            "id": "project-id-1",
-            "name": "new project",
-            "owner": True,
-            "owner_name": "Me",
-            "created_name": "Me",
-            "job_all": True,
-            "dataset_all": True,
-            "model_all": True,
-            "createdAt": "2020-12-31T23:59:59.000Z",
-        }
-
-        mock_trainml._query = AsyncMock(return_value=api_response)
-        response = await projects.create(**requested_config)
-        mock_trainml._query.assert_called_once_with(
-            "/project", "POST", None, expected_payload
-        )
-        assert response.id == "project-id-1"
-
-
-class ProjectDatastoreTests:
-    def test_project_datastore_properties(self, project_datastore):
-        assert isinstance(project_datastore.id, str)
-        assert isinstance(project_datastore.name, str)
-        assert isinstance(project_datastore.project_uuid, str)
-        assert isinstance(project_datastore.type, str)
-        assert isinstance(project_datastore.region_uuid, str)
-
-    def test_project_datastore_str(self, project_datastore):
-        string = str(project_datastore)
-        regex = r"^{.*\"id\": \"" + project_datastore.id + r"\".*}$"
-        assert isinstance(string, str)
-        assert re.match(regex, string)
-
-    def test_project_datastore_repr(self, project_datastore):
-        string = repr(project_datastore)
-        regex = (
-            r"^ProjectDatastore\( trainml , \*\*{.*'id': '"
-            + project_datastore.id
-            + r"'.*}\)$"
-        )
-        assert isinstance(string, str)
-        assert re.match(regex, string)
-
-    def test_project_datastore_bool(self, project_datastore, mock_trainml):
-        empty_project_datastore = specimen.ProjectDatastore(mock_trainml)
-        assert bool(project_datastore)
-        assert not bool(empty_project_datastore)
-
-
-class ProjectDataConnectorTests:
-    def test_project_data_connector_properties(self, project_data_connector):
-        assert isinstance(project_data_connector.id, str)
-        assert isinstance(project_data_connector.name, str)
-        assert isinstance(project_data_connector.project_uuid, str)
-        assert isinstance(project_data_connector.type, str)
-        assert isinstance(project_data_connector.region_uuid, str)
-
-    def test_project_data_connector_str(self, project_data_connector):
-        string = str(project_data_connector)
-        regex = r"^{.*\"id\": \"" + project_data_connector.id + r"\".*}$"
-        assert isinstance(string, str)
-        assert re.match(regex, string)
-
-    def test_project_data_connector_repr(self, project_data_connector):
-        string = repr(project_data_connector)
-        regex = (
-            r"^ProjectDataConnector\( trainml , \*\*{.*'id': '"
-            + project_data_connector.id
-            + r"'.*}\)$"
-        )
-        assert isinstance(string, str)
-        assert re.match(regex, string)
-
-    def test_project_data_connector_bool(self, project_data_connector, mock_trainml):
-        empty_project_data_connector = specimen.ProjectDataConnector(mock_trainml)
-        assert bool(project_data_connector)
-        assert not bool(empty_project_data_connector)
-
-
-class ProjectServiceTests:
-    def test_project_service_properties(self, project_service):
-        assert isinstance(project_service.id, str)
-        assert isinstance(project_service.name, str)
-        assert isinstance(project_service.project_uuid, str)
-        assert isinstance(project_service.hostname, str)
-        assert isinstance(project_service.public, bool)
-        assert isinstance(project_service.region_uuid, str)
-
-    def test_project_service_str(self, project_service):
-        string = str(project_service)
-        regex = r"^{.*\"id\": \"" + project_service.id + r"\".*}$"
-        assert isinstance(string, str)
-        assert re.match(regex, string)
-
-    def test_project_service_repr(self, project_service):
-        string = repr(project_service)
-        regex = (
-            r"^ProjectService\( trainml , \*\*{.*'id': '"
-            + project_service.id
-            + r"'.*}\)$"
-        )
-        assert isinstance(string, str)
-        assert re.match(regex, string)
-
-    def test_project_service_bool(self, project_service, mock_trainml):
-        empty_project_service = specimen.ProjectService(mock_trainml)
-        assert bool(project_service)
-        assert not bool(empty_project_service)
-
-
-class ProjectTests:
-    def test_project_properties(self, project):
-        assert isinstance(project.id, str)
-        assert isinstance(project.name, str)
-        assert isinstance(project.owner_name, str)
-        assert isinstance(project.is_owner, bool)
-
-    def test_project_str(self, project):
-        string = str(project)
-        regex = r"^{.*\"id\": \"" + project.id + r"\".*}$"
-        assert isinstance(string, str)
-        assert re.match(regex, string)
-
-    def test_project_repr(self, project):
-        string = repr(project)
-        regex = r"^Project\( trainml , \*\*{.*'id': '" + project.id + r"'.*}\)$"
-        assert isinstance(string, str)
-        assert re.match(regex, string)
-
-    def test_project_bool(self, project, mock_trainml):
-        empty_project = specimen.Project(mock_trainml)
-        assert bool(project)
-        assert not bool(empty_project)
-
-    @mark.asyncio
-    async def test_project_remove(self, project, mock_trainml):
-        api_response = dict()
-        mock_trainml._query = AsyncMock(return_value=api_response)
-        await project.remove()
-        mock_trainml._query.assert_called_once_with("/project/1", "DELETE")
-
-    @mark.asyncio
-    async def test_project_refresh_datastores(self, project, mock_trainml):
-        api_response = dict()
-        mock_trainml._query = AsyncMock(return_value=api_response)
-        await project.refresh_datastores()
-        mock_trainml._query.assert_called_once_with("/project/1/datastores", "PATCH")
-
-    @mark.asyncio
-    async def test_project_refresh_services(self, project, mock_trainml):
-        api_response = dict()
-        mock_trainml._query = AsyncMock(return_value=api_response)
-        await project.refresh_services()
-        mock_trainml._query.assert_called_once_with("/project/1/services", "PATCH")
-
-    @mark.asyncio
-    async def test_project_list_datastores(self, project, mock_trainml):
-        api_response = [
-            {
-                "project_uuid": "proj-id-1",
-                "region_uuid": "reg-id-1",
-                "id": "store-id-1",
-                "type": "nfs",
-                "name": "On-prem NFS",
-            },
-            {
-                "project_uuid": "proj-id-1",
-                "region_uuid": "reg-id-2",
-                "id": "store-id-2",
-                "type": "smb",
-                "name": "GCP Samba",
-            },
-        ]
-        mock_trainml._query = AsyncMock(return_value=api_response)
-        resp = await project.list_datastores()
-        mock_trainml._query.assert_called_once_with("/project/1/datastores", "GET")
-        assert len(resp) == 2
-
-    @mark.asyncio
-    async def test_project_list_services(self, project, mock_trainml):
-        api_response = [
-            {
-                "project_uuid": "proj-id-1",
-                "region_uuid": "reg-id-1",
-                "id": "res-id-1",
-                "type": "port",
-                "name": "On-Prem Service A",
-                "resource": "8001",
-                "hostname": "service-a.local",
-            },
-            {
-                "project_uuid": "proj-id-1",
-                "region_uuid": "reg-id-2",
-                "id": "res-id-2",
-                "type": "port",
-                "name": "Cloud Service B",
-                "resource": "8001",
-                "hostname": "service-b.local",
-            },
-        ]
-        mock_trainml._query = AsyncMock(return_value=api_response)
-        resp = await project.list_services()
-        mock_trainml._query.assert_called_once_with("/project/1/services", "GET")
-        assert len(resp) == 2

tests/unit/test_trainml.py

@@ -1,54 +0,0 @@
-import re
-import logging
-import json
-import os
-from unittest.mock import AsyncMock, patch, mock_open
-from pytest import mark, fixture, raises
-from aiohttp import WSMessage, WSMsgType
-
-import trainml.trainml as specimen
-
-pytestmark = [mark.sdk, mark.unit]
-
-
-@patch.dict(
-    os.environ,
-    {
-        "TRAINML_USER": "user-id",
-        "TRAINML_KEY": "key",
-        "TRAINML_REGION": "region",
-        "TRAINML_CLIENT_ID": "client_id",
-        "TRAINML_POOL_ID": "pool_id",
-        "TRAINML_API_URL": "api.example.com",
-        "TRAINML_WS_URL": "api-ws.example.com",
-    },
-)
-def test_trainml_from_envs():
-    trainml = specimen.TrainML()
-    assert trainml.__dict__.get("api_url") == "api.example.com"
-    assert trainml.__dict__.get("ws_url") == "api-ws.example.com"
-    assert trainml.auth.__dict__.get("username") == "user-id"
-    assert trainml.auth.__dict__.get("password") == "key"
-    assert trainml.auth.__dict__.get("region") == "region"
-    assert trainml.auth.__dict__.get("client_id") == "client_id"
-    assert trainml.auth.__dict__.get("pool_id") == "pool_id"
-
-
-def test_trainml_env_from_files():
-    with patch(
-        "trainml.trainml.open",
-        mock_open(
-            read_data=json.dumps(
-                dict(
-                    region="region_file",
-                    client_id="client_id_file",
-                    pool_id="pool_id_file",
-                    api_url="api.example.com_file",
-                    ws_url="api-ws.example.com_file",
-                )
-            )
-        ),
-    ):
-        trainml = specimen.TrainML()
-    assert trainml.__dict__.get("api_url") == "api.example.com_file"
-    assert trainml.__dict__.get("ws_url") == "api-ws.example.com_file"