proximl 0.5.8__py3-none-any.whl → 0.5.9__py3-none-any.whl

proximl/cli/project/__init__.py

@@ -0,0 +1,153 @@
+import click
+from proximl.cli import cli, pass_config, search_by_id_name
+
+
+@cli.group()
+@pass_config
+def project(config):
+    """proxiML project commands."""
+    pass
+
+
+@project.command()
+@pass_config
+def list(config):
+    """List projects."""
+    data = [
+        ["ID", "NAME", "OWNER", "MINE"],
+        [
+            "-" * 80,
+            "-" * 80,
+            "-" * 80,
+            "-" * 80,
+        ],
+    ]
+
+    projects = config.proximl.run(config.proximl.client.projects.list())
+
+    for project in projects:
+        data.append(
+            [
+                project.id,
+                project.name,
+                project.owner_name,
+                "X" if project.is_owner else "",
+            ]
+        )
+
+    for row in data:
+        click.echo(
+            "{: >38.36} {: >30.28} {: >15.13} {: >4.4}" "".format(*row),
+            file=config.stdout,
+        )
+
+
+@project.command()
+@click.argument("name", type=click.STRING)
+@pass_config
+def create(config, name):
+    """
+    Create a project.
+
+    Project is created with the specified NAME.
+    """
+
+    return config.proximl.run(
+        config.proximl.client.projects.create(
+            name=name,
+        )
+    )
+
+
+@project.command()
+@click.argument("project", type=click.STRING)
+@pass_config
+def remove(config, project):
+    """
+    Remove a project.
+
+    PROJECT may be specified by name or ID, but ID is preferred.
+    """
+    projects = config.proximl.run(config.proximl.client.projects.list())
+
+    found = search_by_id_name(project, projects)
+    if None is found:
+        raise click.UsageError("Cannot find specified project.")
+
+    return config.proximl.run(found.remove())
+
+
+@project.command()
+@pass_config
+def list_datastores(config):
+    """List project datastores."""
+    data = [
+        ["ID", "NAME", "TYPE", "REGION_UUID"],
+        [
+            "-" * 80,
+            "-" * 80,
+            "-" * 80,
+            "-" * 80,
+        ],
+    ]
+    project = config.proximl.run(
+        config.proximl.client.projects.get(config.proximl.client.project)
+    )
+
+    datastores = config.proximl.run(project.list_datastores())
+
+    for datastore in datastores:
+        data.append(
+            [
+                datastore.id,
+                datastore.name,
+                datastore.type,
+                datastore.region_uuid,
+            ]
+        )
+
+    for row in data:
+        click.echo(
+            "{: >38.36} {: >30.28} {: >15.13} {: >38.36}" "".format(*row),
+            file=config.stdout,
+        )
+
+
+@project.command()
+@pass_config
+def list_services(config):
+    """List project services."""
+    data = [
+        ["ID", "NAME", "HOSTNAME", "REGION_UUID"],
+        [
+            "-" * 80,
+            "-" * 80,
+            "-" * 80,
+            "-" * 80,
+        ],
+    ]
+    project = config.proximl.run(
+        config.proximl.client.projects.get(config.proximl.client.project)
+    )
+
+    services = config.proximl.run(project.list_services())
+
+    for service in services:
+        data.append(
+            [
+                service.id,
+                service.name,
+                service.hostname,
+                service.region_uuid,
+            ]
+        )
+
+    for row in data:
+        click.echo(
+            "{: >38.36} {: >30.28} {: >30.28} {: >38.36}" "".format(*row),
+            file=config.stdout,
+        )
+
+
+from proximl.cli.project.secret import secret
+from proximl.cli.project.key import key

proximl/cli/project/key.py

@@ -0,0 +1,124 @@
+import click
+import os
+import json
+import base64
+from pathlib import Path
+from proximl.cli import pass_config
+from proximl.cli.project import project
+
+
+@project.group()
+@pass_config
+def key(config):
+    """proxiML project key commands."""
+    pass
+
+
+@key.command()
+@pass_config
+def list(config):
+    """List keys."""
+    data = [
+        ["TYPE", "KEY ID", "UPDATED AT"],
+        [
+            "-" * 80,
+            "-" * 80,
+            "-" * 80,
+        ],
+    ]
+    project = config.proximl.run(config.proximl.client.projects.get_current())
+    keys = config.proximl.run(project.keys.list())
+
+    for key in keys:
+        data.append(
+            [
+                key.type,
+                key.key_id,
+                key.updated_at.isoformat(timespec="seconds"),
+            ]
+        )
+
+    for row in data:
+        click.echo(
+            "{: >13.11} {: >37.35} {: >28.26}" "".format(*row),
+            file=config.stdout,
+        )
+
+
+@key.command()
+@click.argument(
+    "type",
+    type=click.Choice(
+        [
+            "aws",
+            "azure",
+            "docker",
+            "gcp",
+            "huggingface",
+            "kaggle",
+            "ngc",
+            "wasabi",
+        ],
+        case_sensitive=False,
+    ),
+)
+@pass_config
+def put(config, type):
+    """
+    Set a key.
+
+    A key is uploaded.
+    """
+    project = config.proximl.run(config.proximl.client.projects.get_current())
+
+    tenant = None
+
+    if type in ["aws", "wasabi"]:
+        key_id = click.prompt("Enter the key ID", type=str, hide_input=False)
+        secret = click.prompt("Enter the secret key", type=str, hide_input=True)
+    elif type == "azure":
+        key_id = click.prompt(
+            "Enter the Application (client) ID", type=str, hide_input=False
+        )
+        tenant = click.prompt(
+            "Enter the Directory (tenant) ley", type=str, hide_input=False
+        )
+        secret = click.prompt("Enter the client secret", type=str, hide_input=True)
+    elif type in ["docker", "huggingface"]:
+        key_id = click.prompt("Enter the username", type=str, hide_input=False)
+        secret = click.prompt("Enter the access token", type=str, hide_input=True)
+    elif type in ["gcp", "kaggle"]:
+        file_name = click.prompt(
+            "Enter the path of the credentials file",
+            type=click.Path(
+                exists=True, file_okay=True, dir_okay=False, resolve_path=True
+            ),
+            hide_input=False,
+        )
+        key_id = os.path.basename(file_name)
+        with open(file_name) as f:
+            secret = json.load(f)
+        secret = json.dumps(secret)
+    elif type == "ngc":
+        key_id = "$oauthtoken"
+        secret = click.prompt("Enter the access token", type=str, hide_input=True)
+    else:
+        raise click.UsageError("Unsupported key type")
+
+    return config.proximl.run(
+        project.keys.put(type=type, key_id=key_id, secret=secret, tenant=tenant)
+    )
+
+
+@key.command()
+@click.argument("name", type=click.STRING)
+@pass_config
+def remove(config, name):
+    """
+    Remove a key.
+
+
+    """
+    project = config.proximl.run(config.proximl.client.projects.get_current())
+
+    return config.proximl.run(project.key.remove(name))

proximl/cli/project/secret.py

@@ -0,0 +1,71 @@
+import click
+from proximl.cli import pass_config
+from proximl.cli.project import project
+
+
+@project.group()
+@pass_config
+def secret(config):
+    """proxiML project secret commands."""
+    pass
+
+
+@secret.command()
+@pass_config
+def list(config):
+    """List secrets."""
+    data = [
+        ["NAME", "CREATED BY", "UPDATED AT"],
+        [
+            "-" * 80,
+            "-" * 80,
+            "-" * 80,
+        ],
+    ]
+    project = config.proximl.run(config.proximl.client.projects.get_current())
+    secrets = config.proximl.run(project.secrets.list())
+
+    for secret in secrets:
+        data.append(
+            [
+                secret.name,
+                secret.created_by,
+                secret.updated_at.isoformat(timespec="seconds"),
+            ]
+        )
+
+    for row in data:
+        click.echo(
+            "{: >38.36} {: >30.28} {: >28.26}" "".format(*row),
+            file=config.stdout,
+        )
+
+
+@secret.command()
+@click.argument("name", type=click.STRING)
+@pass_config
+def put(config, name):
+    """
+    Set a secret value.
+
+    Secret is created with the specified NAME.
+    """
+    project = config.proximl.run(config.proximl.client.projects.get_current())
+
+    value = click.prompt("Enter the secret value", type=str, hide_input=True)
+
+    return config.proximl.run(project.secrets.put(name=name, value=value))
+
+
+@secret.command()
+@click.argument("name", type=click.STRING)
+@pass_config
+def remove(config, name):
+    """
+    Remove a secret.
+
+
+    """
+    project = config.proximl.run(config.proximl.client.projects.get_current())
+
+    return config.proximl.run(project.secret.remove(name))

proximl/projects/__init__.py

@@ -0,0 +1,3 @@
+from .projects import Projects, Project
+
+__all__ = ["Projects", "Project"]

proximl/projects/data_connectors.py

@@ -0,0 +1,63 @@
+import json
+import logging
+
+
+class ProjectDataConnectors(object):
+    def __init__(self, proximl, project_id):
+        self.proximl = proximl
+        self.project_id = project_id
+
+    async def list(self, **kwargs):
+        resp = await self.proximl._query(
+            f"/project/{self.project_id}/data_connectors", "GET", kwargs
+        )
+        data_connectors = [
+            ProjectDataConnector(self.proximl, **data_connector)
+            for data_connector in resp
+        ]
+        return data_connectors
+
+    async def refresh(self):
+        await self.proximl._query(
+            f"/project/{self.project_id}/data_connectors", "PATCH"
+        )
+
+
+class ProjectDataConnector:
+    def __init__(self, proximl, **kwargs):
+        self.proximl = proximl
+        self._entity = kwargs
+        self._id = self._entity.get("id")
+        self._project_uuid = self._entity.get("project_uuid")
+        self._name = self._entity.get("name")
+        self._type = self._entity.get("type")
+        self._region_uuid = self._entity.get("region_uuid")
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+    @property
+    def project_uuid(self) -> str:
+        return self._project_uuid
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def type(self) -> str:
+        return self._type
+
+    @property
+    def region_uuid(self) -> str:
+        return self._region_uuid
+
+    def __str__(self):
+        return json.dumps({k: v for k, v in self._entity.items()})
+
+    def __repr__(self):
+        return f"ProjectDataConnector( proximl , **{self._entity.__repr__()})"
+
+    def __bool__(self):
+        return bool(self._id)

proximl/projects/datastores.py

@@ -0,0 +1,58 @@
+import json
+import logging
+
+
+class ProjectDatastores(object):
+    def __init__(self, proximl, project_id):
+        self.proximl = proximl
+        self.project_id = project_id
+
+    async def list(self, **kwargs):
+        resp = await self.proximl._query(
+            f"/project/{self.project_id}/datastores", "GET", kwargs
+        )
+        datastores = [ProjectDatastore(self.proximl, **datastore) for datastore in resp]
+        return datastores
+
+    async def refresh(self):
+        await self.proximl._query(f"/project/{self.project_id}/datastores", "PATCH")
+
+
+class ProjectDatastore:
+    def __init__(self, proximl, **kwargs):
+        self.proximl = proximl
+        self._entity = kwargs
+        self._id = self._entity.get("id")
+        self._project_uuid = self._entity.get("project_uuid")
+        self._name = self._entity.get("name")
+        self._type = self._entity.get("type")
+        self._region_uuid = self._entity.get("region_uuid")
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+    @property
+    def project_uuid(self) -> str:
+        return self._project_uuid
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def type(self) -> str:
+        return self._type
+
+    @property
+    def region_uuid(self) -> str:
+        return self._region_uuid
+
+    def __str__(self):
+        return json.dumps({k: v for k, v in self._entity.items()})
+
+    def __repr__(self):
+        return f"ProjectDatastore( proximl , **{self._entity.__repr__()})"
+
+    def __bool__(self):
+        return bool(self._id)

proximl/projects/keys.py

@@ -0,0 +1,71 @@
+import json
+import logging
+from datetime import datetime
+from dateutil import parser, tz
+
+
+class ProjectKeys(object):
+    def __init__(self, proximl, project_id):
+        self.proximl = proximl
+        self.project_id = project_id
+
+    async def list(self, **kwargs):
+        resp = await self.proximl._query(
+            f"/project/{self.project_id}/keys", "GET", kwargs
+        )
+        keys = [ProjectKey(self.proximl, **service) for service in resp]
+        return keys
+
+    async def put(self, type, key_id, secret, tenant=None, **kwargs):
+        data = dict(key_id=key_id, secret=secret, tenant=tenant)
+        payload = {k: v for k, v in data.items() if v is not None}
+        logging.info(f"Creating Project Key {type}")
+        resp = await self.proximl._query(
+            f"/project/{self.project_id}/key/{type}", "PUT", None, payload
+        )
+        key = ProjectKey(self.proximl, **resp)
+        logging.info(f"Created Project Key {type} in project {self.project_id}")
+
+        return key
+
+    async def remove(self, type, **kwargs):
+        await self.proximl._query(
+            f"/project/{self.project_id}/key/{type}", "DELETE", kwargs
+        )
+
+
+class ProjectKey:
+    def __init__(self, proximl, **kwargs):
+        self.proximl = proximl
+        self._entity = kwargs
+        self._type = self._entity.get("type")
+        self._project_uuid = self._entity.get("project_uuid")
+        self._key_id = self._entity.get("key_id")
+        self._updated_at = self._entity.get("updatedAt")
+
+    @property
+    def type(self) -> str:
+        return self._type
+
+    @property
+    def project_uuid(self) -> str:
+        return self._project_uuid
+
+    @property
+    def key_id(self) -> str:
+        return self._key_id
+
+    @property
+    def updated_at(self) -> datetime:
+        timestamp = parser.isoparse(self._updated_at)
+        timezone = tz.tzlocal()
+        return timestamp.astimezone(timezone)
+
+    def __str__(self):
+        return json.dumps({k: v for k, v in self._entity.items()})
+
+    def __repr__(self):
+        return f"ProjectKey( proximl , **{self._entity.__repr__()})"
+
+    def __bool__(self):
+        return bool(self._type)

proximl/projects/projects.py

@@ -0,0 +1,83 @@
+import json
+import logging
+from .datastores import ProjectDatastores
+from .data_connectors import ProjectDataConnectors
+from .services import ProjectServices
+from .keys import ProjectKeys
+from .secrets import ProjectSecrets
+
+
+class Projects(object):
+    def __init__(self, proximl):
+        self.proximl = proximl
+
+    async def get(self, id, **kwargs):
+        resp = await self.proximl._query(f"/project/{id}", "GET", kwargs)
+        return Project(self.proximl, **resp)
+
+    async def get_current(self, **kwargs):
+        resp = await self.proximl._query(
+            f"/project/{self.proximl.project}", "GET", kwargs
+        )
+        return Project(self.proximl, **resp)
+
+    async def list(self, **kwargs):
+        resp = await self.proximl._query(f"/project", "GET", kwargs)
+        projects = [Project(self.proximl, **project) for project in resp]
+        return projects
+
+    async def create(self, name, copy_keys=False, copy_secrets=False, **kwargs):
+        data = dict(name=name, copy_keys=copy_keys, copy_secrets=copy_secrets)
+        payload = {k: v for k, v in data.items() if v is not None}
+        logging.info(f"Creating Project {name}")
+        resp = await self.proximl._query("/project", "POST", None, payload)
+        project = Project(self.proximl, **resp)
+        logging.info(f"Created Project {name} with id {project.id}")
+
+        return project
+
+    async def remove(self, id, **kwargs):
+        await self.proximl._query(f"/project/{id}", "DELETE", kwargs)
+
+
+class Project:
+    def __init__(self, proximl, **kwargs):
+        self.proximl = proximl
+        self._entity = kwargs
+        self._id = self._entity.get("id")
+        self._name = self._entity.get("name")
+        self._is_owner = self._entity.get("owner")
+        self._owner_name = self._entity.get("owner_name")
+        self.datastores = ProjectDatastores(self.proximl, self._id)
+        self.data_connectors = ProjectDataConnectors(self.proximl, self._id)
+        self.services = ProjectServices(self.proximl, self._id)
+        self.keys = ProjectKeys(self.proximl, self._id)
+        self.secrets = ProjectSecrets(self.proximl, self._id)
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def is_owner(self) -> bool:
+        return self._is_owner
+
+    @property
+    def owner_name(self) -> str:
+        return self._owner_name
+
+    def __str__(self):
+        return json.dumps({k: v for k, v in self._entity.items()})
+
+    def __repr__(self):
+        return f"Project( proximl , **{self._entity.__repr__()})"
+
+    def __bool__(self):
+        return bool(self._id)
+
+    async def remove(self):
+        await self.proximl._query(f"/project/{self._id}", "DELETE")

proximl/projects/secrets.py

@@ -0,0 +1,70 @@
+import json
+import logging
+from datetime import datetime
+from dateutil import parser, tz
+
+
+class ProjectSecrets(object):
+    def __init__(self, proximl, project_id):
+        self.proximl = proximl
+        self.project_id = project_id
+
+    async def list(self, **kwargs):
+        resp = await self.proximl._query(
+            f"/project/{self.project_id}/secrets", "GET", kwargs
+        )
+        secrets = [ProjectSecret(self.proximl, **service) for service in resp]
+        return secrets
+
+    async def put(self, name, value, **kwargs):
+        data = dict(value=value)
+        payload = {k: v for k, v in data.items() if v is not None}
+        logging.info(f"Creating Project Secret {name}")
+        resp = await self.proximl._query(
+            f"/project/{self.project_id}/secret/{name}", "PUT", None, payload
+        )
+        secret = ProjectSecret(self.proximl, **resp)
+        logging.info(f"Created Project Key {name} in project {self.project_id}")
+        return secret
+
+    async def remove(self, name, **kwargs):
+        await self.proximl._query(
+            f"/project/{self.project_id}/secret/{name}", "DELETE", kwargs
+        )
+
+
+class ProjectSecret:
+    def __init__(self, proximl, **kwargs):
+        self.proximl = proximl
+        self._entity = kwargs
+        self._name = self._entity.get("name")
+        self._project_uuid = self._entity.get("project_uuid")
+        self._created_by = self._entity.get("created_by")
+        self._updated_at = self._entity.get("updatedAt")
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def project_uuid(self) -> str:
+        return self._project_uuid
+
+    @property
+    def created_by(self) -> str:
+        return self._created_by
+
+    @property
+    def updated_at(self) -> datetime:
+        timestamp = parser.isoparse(self._updated_at)
+        timezone = tz.tzlocal()
+        return timestamp.astimezone(timezone)
+
+    def __str__(self):
+        return json.dumps({k: v for k, v in self._entity.items()})
+
+    def __repr__(self):
+        return f"ProjectSecret( proximl , **{self._entity.__repr__()})"
+
+    def __bool__(self):
+        return bool(self._name)