seqslab-cli 3.2.6__tar.gz → 3.2.7__tar.gz

{seqslab-cli-3.2.6/python/seqslab_cli.egg-info → seqslab-cli-3.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: seqslab-cli
-Version: 3.2.6
+Version: 3.2.7
 Summary: Atgenomix SeqsLab Command Line Tool
 Home-page: https://github.com/AnomeGAP/seqslab-cli
 Author: Allen Chang

{seqslab-cli-3.2.6 → seqslab-cli-3.2.7}/python/seqslab/__init__.py

@@ -23,7 +23,7 @@ __all__ = [
 ]
 
 
-__version__ = "3.2.6"
+__version__ = "3.2.7"
 
 LOGGING = {
     "DIR_PATH": "/var/log/seqslab"

{seqslab-cli-3.2.6 → seqslab-cli-3.2.7}/python/seqslab/cli.py

@@ -21,7 +21,7 @@ import signal
 
 from nubia import Nubia, Options
 
-from seqslab import auth, drs, wes, trs, workspace, user, role, organization
+from seqslab import auth, drs, wes, trs, workspace, user, role, organization, scr
 from seqslab.plugin import SQLBPlugin
 
 
@@ -42,7 +42,7 @@ def main():
     plugin = SQLBPlugin()
     shell = Nubia(
         name="seqslab-cli",
-        command_pkgs=[auth, drs, wes, trs, workspace, user, role, organization],
+        command_pkgs=[auth, drs, wes, trs, workspace, user, role, organization, scr],
         plugin=plugin,
         options=Options(
             persistent_history=False,

{seqslab-cli-3.2.6 → seqslab-cli-3.2.7}/python/seqslab/drs/api/base.py

@@ -63,6 +63,7 @@ class DRSregister:
     DRS_RESOURCES_URL = f"https://{API_HOSTNAME}/ga4gh/drs/{__version__}/service-info/workspaces/{{" \
                         f"name}}/resources/?backend={{backend}} "
     DRS_UPLOAD_URL = f"https://{API_HOSTNAME}/ga4gh/drs/{__version__}/objects/upload/?backend={{backend}}"
+    DRS_CONTENTS_ACCESS_URL = f"https://{API_HOSTNAME}/ga4gh/drs/{__version__}/contents/{{object_id}}/access/"
 
     @lru_cache(maxsize=16)
     def root_path(self, workspace_name: str) -> str:
@@ -346,3 +347,19 @@ class DRSregister:
             checksums=obj.get('checksums')
         )._asdict()
         return results
+
+    def create_download_link(self, drs_id: str):
+        """
+        api: ga4gh/drs/v1/contents/${drs_id}/access/
+        :response: download url for the given drs_id
+        """
+        try:
+            token = BaseAuth.get_token().get("tokens").get("access")
+        except KeyError:
+            raise KeyError(f"No tokens, Please sign in first!")
+
+        with requests.post(url=self.DRS_CONTENTS_ACCESS_URL.format(object_id=drs_id),
+                           headers={"Authorization": f"Bearer {token}"}) as response:
+            if response.status_code not in [requests.codes.created]:
+                raise requests.HTTPError(f"{response.status_code}: {repr(response.text)}")
+            return response.json()

{seqslab-cli-3.2.6 → seqslab-cli-3.2.7}/python/seqslab/drs/commands.py

@@ -347,6 +347,34 @@ class BaseDatahub:
         __log(result, output)
         return 0
 
+    @command
+    @argument("workspace",
+              type=str,
+              positional=False,
+              description="Specify the workspace based on the signed in account (required).", )
+    @argument("id",
+              type=str,
+              positional=False,
+              description="A DRS object ID (required if there is no self URI).")
+    def share_link(self, workspace: str, id: str) -> int:
+        """
+        Generate a share link enabling external users to download the DRS object as a zip archive through web
+        browsers. The share link expires either after the first successful download or after a period of three months.
+        """
+
+        if not workspace:
+            logging.error("Invalid workspace name")
+            cprint("Invalid workspace name", "red")
+            return errno.EINVAL
+
+        api_backend = drs_register().load_register(workspace)
+        r = api_backend.create_download_link(drs_id=id)
+
+        if isinstance(r, int):
+            return r
+        cprint(r.get('url'), 'yellow')
+        return 0
+
     @staticmethod
     @async_exception_handler
     async def _download(drs_id: str, dst: str, **kwargs):

seqslab-cli-3.2.7/python/seqslab/scr/__init__.py

@@ -0,0 +1,15 @@
+import environ
+
+env = environ.Env()
+environ.Env.read_env("/etc/seqslab/cli_apps.env")
+
+name = "scr"
+
+__all__ = [
+
+]
+
+__version__ = "v3"
+
+PRIVATE_NAME = env.str("PRIVATE_NAME", "api")
+API_HOSTNAME = f"{PRIVATE_NAME}.seqslab.net"

seqslab-cli-3.2.7/python/seqslab/scr/commands.py

@@ -0,0 +1,209 @@
+import base64
+import csv
+import errno
+import json
+import logging
+import re
+from io import StringIO
+from typing import List
+
+from nubia import argument, command, context
+from tabulate import tabulate
+from termcolor import cprint
+
+from seqslab.exceptions import exception_handler
+from .internal.common import get_factory
+
+
+class BaseSCR:
+
+    @command(aliases=[])
+    @argument("reload",
+              type=bool,
+              positional=False,
+              description="Specify whether to force reload system cache for SCR (optional, default = False).")
+    def list(self, reload: bool = False) -> int:
+        """
+            List all SCR records.
+        """
+
+        backend = get_factory().load_resource()
+        result = backend.list_scr(reload)
+
+        if isinstance(result, int):
+            return result
+        self.__log(result)
+        return 0
+
+    @command(aliases=[])
+    @argument("login_server",
+              type=str,
+              positional=False,
+              description="Specify a container registry login endpoint, e.g. docker.io (required).")
+    @argument("username",
+              type=str,
+              positional=False,
+              description="Specify the account for this container registry (required).")
+    @argument("password",
+              type=str,
+              positional=False,
+              description="Specify the password for this container registry (required).")
+    def register(self, login_server: str, username: str, password: str) -> int:
+        """
+            Register a container registry to SCR.
+        """
+
+        backend = get_factory().load_resource()
+        kwargs = {"login_server": login_server, "username": username, "password": password}
+        result = backend.register_scr(**kwargs)
+
+        if isinstance(result, int):
+            return result
+        self.__log(result)
+        return 0
+
+    @command(aliases=[])
+    @argument("id",
+              type=str,
+              positional=False,
+              description="Specify the ID of the SCR (required).")
+    @argument("reload",
+              type=bool,
+              positional=False,
+              description="Specify whether to force reload system cache for SCR (optional, default = False).")
+    def get(self, id: str, reload: bool = False) -> int:
+        """
+            Get an SCR record.
+        """
+
+        backend = get_factory().load_resource()
+        kwargs = {"id": id, "reload": reload}
+        result = backend.get_scr(**kwargs)
+        if isinstance(result, int):
+            return result
+
+        auth = base64.b64decode(result.get('authorization')[6:]).decode('utf-8').split(':')
+        result['username'] = auth[0]
+        result['password'] = auth[1]
+
+        self.__log(result)
+        return 0
+
+    @command(aliases=[])
+    @argument("id",
+              type=str,
+              positional=False,
+              description="Specify the ID of an SCR (required).")
+    @argument("username",
+              type=str,
+              positional=False,
+              description="Specify the account for this container registry (optional).")
+    @argument("password",
+              type=str,
+              positional=False,
+              description="Specify the password for this container registry (optional).")
+    def update(self, id: str, username: str = '', password: str = '') -> int:
+        """
+            Update an SCR record.
+        """
+
+        backend = get_factory().load_resource()
+        kwargs = {}
+        if username:
+            kwargs['username'] = username
+        if password:
+            kwargs["password"] = password
+        if not kwargs:
+            cprint('Nothing to be done due to username and password are not given')
+            return 0
+
+        result = backend.update_scr(id, **kwargs)
+        if isinstance(result, int):
+            return result
+        self.__log(result)
+        return 0
+
+    @command(aliases=[])
+    @argument("id",
+              type=str,
+              positional=False,
+              description="Specify the ID of the SCR (required).")
+    def deregister(self, id: str) -> int:
+        """
+            Deregister an SCR record.
+        """
+
+        backend = get_factory().load_resource()
+        kwargs = {}
+        result = backend.deregister_scr(id, **kwargs)
+
+        if isinstance(result, int):
+            return result
+        self.__log(result)
+        return 0
+
+    @command(aliases=[])
+    @argument("id",
+              type=str,
+              positional=False,
+              description="Specify the ID of the SCR (required).")
+    @argument("repository",
+              type=str,
+              positional=False,
+              description="Specify the repository name (required).")
+    @argument("reload",
+              type=bool,
+              positional=False,
+              description="Specify whether to force reload system cache for SCR (optional, default = False).")
+    def repository(self, id: str, repository: str, reload: bool = False) -> int:
+        """
+            Get repository.
+        """
+
+        backend = get_factory().load_resource()
+        kwargs = {"registry_id": id, "repository_name": repository, "reload": reload}
+        result = backend.get_repository(**kwargs)
+        if isinstance(result, int):
+            return result
+
+        self.__log(result)
+        return 0
+
+    def __log(self, results):
+        self._stdout(results=results, output='json')
+        msg = f"List all workspaces."
+        logging.info(msg)
+
+    @staticmethod
+    def _stdout(results: List[dict], output: str) -> int:
+        """
+            stdout:: support different format [json, tsv, table]
+        """
+        if output == "tsv":
+            s = StringIO()
+            writer = csv.DictWriter(s, fieldnames=list(results[0].keys()))
+            writer.writeheader()
+            for result in results:
+                writer.writerow(result)
+            s.seek(0)
+            content = s.read().replace(',', '\t')
+            cprint(content)
+        elif output == 'table':
+            table_header = list(results[0].keys())
+            table_datas = [result.values() for result in results]
+            cprint(tabulate(
+                tabular_data=table_datas,
+                headers=table_header,
+                tablefmt='pipe'
+            ))
+        else:
+            cprint(json.dumps(results, indent=4))
+        return 0
+
+
+@command
+class scr(BaseSCR):
+    """ SeqsLab Container Registry SCR commands"""
+
+    def __init__(self):
+        pass

seqslab-cli-3.2.7/python/seqslab/scr/internal/common.py

@@ -0,0 +1,46 @@
+import sys
+from typing import TypeVar
+
+from nubia import context
+from seqslab.wes.resource.azure import AzureResource
+from seqslab.settings import SCR_RESOURCE_BACKEND
+
+
+"""
+Copyright (C) 2022, Atgenomix Incorporated.
+
+All Rights Reserved.
+
+This program is an unpublished copyrighted work which is proprietary to
+Atgenomix Incorporated and contains confidential information that is not to
+be reproduced or disclosed to any other person or entity without prior
+written consent from Atgenomix, Inc. in each and every instance.
+
+Unauthorized reproduction of this program as well as unauthorized
+preparation of derivative works based upon the program or distribution of
+copies by sale, rental, lease or lending are violations of federal copyright
+laws and state trade secret laws, punishable by civil and criminal penalties.
+"""
+
+Resource = TypeVar("Resource", bound=AzureResource)
+
+
+class Factory:
+    """Storage backend factory"""
+
+    @staticmethod
+    def load_resource() -> Resource:
+        backend = context.get_context().args.backend
+        name = SCR_RESOURCE_BACKEND.get(backend)
+        mod, mem = name.rsplit(".", 1)
+        __import__(mod)
+        module = sys.modules[mod]
+        backend_class = getattr(module, mem)
+        return backend_class()
+
+
+_factory = Factory()
+
+
+def get_factory():
+    return _factory

seqslab-cli-3.2.7/python/seqslab/scr/resource/base.py

@@ -0,0 +1,124 @@
+import requests
+import logging
+from tenacity import retry, wait_fixed, stop_after_attempt
+from seqslab.auth.commands import BaseAuth
+from seqslab import trs, drs, wes, workspace, scr
+from functools import lru_cache
+from nubia import context
+
+
+class BaseResource:
+    logger = logging.getLogger()
+    TRS_BASE_URL = f"https://{trs.API_HOSTNAME}/trs/{trs.__version__}"
+    TRS_CR_URL = f"{TRS_BASE_URL}/container-registry/"
+    TRS_CR_REPO_URL = f"{TRS_CR_URL}{{registry_id}}/repository/{{repository_name}}"
+    @staticmethod
+    @retry(stop=stop_after_attempt(3), wait=wait_fixed(2), reraise=True)
+    def request_wrapper(
+            callback,
+            url,
+            headers,
+            status,
+            data=None,
+            stream=False,
+    ) -> requests.Response:
+        with callback(url, headers=headers, data=data, stream=stream) as r:
+            if r.status_code in status:
+                return r
+            r.raise_for_status()
+
+    @staticmethod
+    @retry(stop=stop_after_attempt(3), wait=wait_fixed(2), reraise=True)
+    @lru_cache(maxsize=16)
+    def list_scr(reload: bool):
+        ctx = context.get_context()
+        backend = ctx.args.backend
+        token = BaseAuth.get_token().get("tokens").get("access")
+        url = BaseResource.TRS_CR_URL.format(backend=backend) + f'?backend={backend}'
+        if reload:
+            url += f'&force=true'
+        r = BaseResource.request_wrapper(
+            callback=requests.get,
+            url=BaseResource.TRS_CR_URL.format(backend=backend),
+            headers={"Authorization": f"Bearer {token}"},
+            status=[requests.codes.ok])
+        return r.json()
+
+    @staticmethod
+    @retry(stop=stop_after_attempt(3), wait=wait_fixed(2), reraise=True)
+    def register_scr(**kwargs):
+        ctx = context.get_context()
+        backend = ctx.args.backend
+        token = BaseAuth.get_token().get("tokens").get("access")
+        r = BaseResource.request_wrapper(
+            callback=requests.post,
+            url=BaseResource.TRS_CR_URL.format(backend=backend) + f'?backend={backend}',
+            headers={"Authorization": f"Bearer {token}"},
+            status=[requests.codes.created],
+            data=kwargs)
+        return r.json()
+
+    @staticmethod
+    @retry(stop=stop_after_attempt(3), wait=wait_fixed(2), reraise=True)
+    @lru_cache(maxsize=16)
+    def get_scr(**kwargs):
+        ctx = context.get_context()
+        backend = ctx.args.backend
+        token = BaseAuth.get_token().get("tokens").get("access")
+        url = BaseResource.TRS_CR_URL.format(backend=backend) + f"{kwargs.get('id')}/"
+        if kwargs.get('reload'):
+            url += '?force=true'
+
+        r = BaseResource.request_wrapper(
+            callback=requests.get,
+            url=url,
+            headers={"Authorization": f"Bearer {token}"},
+            status=[requests.codes.ok])
+        return r.json()
+
+    @staticmethod
+    @retry(stop=stop_after_attempt(3), wait=wait_fixed(2), reraise=True)
+    def update_scr(scr_id: str, **kwargs):
+        ctx = context.get_context()
+        backend = ctx.args.backend
+        token = BaseAuth.get_token().get("tokens").get("access")
+        r = BaseResource.request_wrapper(
+            callback=requests.patch,
+            url=BaseResource.TRS_CR_URL.format(backend=backend) + f'{scr_id}/',
+            headers={"Authorization": f"Bearer {token}"},
+            data=kwargs,
+            status=[requests.codes.ok])
+        return r.json()
+
+    @staticmethod
+    @retry(stop=stop_after_attempt(3), wait=wait_fixed(2), reraise=True)
+    def deregister_scr(scr_id: str, **kwargs):
+        ctx = context.get_context()
+        backend = ctx.args.backend
+        token = BaseAuth.get_token().get("tokens").get("access")
+        BaseResource.request_wrapper(
+            callback=requests.delete,
+            url=BaseResource.TRS_CR_URL.format(backend=backend) + f'{scr_id}/',
+            headers={"Authorization": f"Bearer {token}"},
+            status=[requests.codes.no_content])
+
+    @staticmethod
+    @retry(stop=stop_after_attempt(3), wait=wait_fixed(2), reraise=True)
+    @lru_cache(maxsize=16)
+    def get_repository(**kwargs):
+        ctx = context.get_context()
+        backend = ctx.args.backend
+        token = BaseAuth.get_token().get("tokens").get("access")
+        url = BaseResource.TRS_CR_REPO_URL.format(
+            registry_id=kwargs.get('registry_id'),
+            repository_name=kwargs.get('repository_name'),
+        )
+        if kwargs.get('reload'):
+            url += '?force=true'
+
+        r = BaseResource.request_wrapper(
+            callback=requests.get,
+            url=url,
+            headers={"Authorization": f"Bearer {token}"},
+            status=[requests.codes.ok])
+        return r.json()

{seqslab-cli-3.2.6 → seqslab-cli-3.2.7}/python/seqslab/settings.py

@@ -33,4 +33,8 @@ ROLE_RESOURCE_BACKEND = {
 
 USER_RESOURCE_BACKEND = {
     "azure": "seqslab.user.resource.azure.AzureResource",
+}
+
+SCR_RESOURCE_BACKEND = {
+    "azure": "seqslab.scr.resource.azure.AzureResource",
 }

{seqslab-cli-3.2.6 → seqslab-cli-3.2.7}/python/seqslab/trs/commands.py

@@ -271,21 +271,31 @@ class BaseTools:
         return 0
 
     @command
-    @argument("workspace",
+    @argument("scr_id",
               type=str,
-              description="Specify the workspace based on the signed in account (required).")
-    def images(self, workspace) -> int:
+              description="Specify SCR ID (required).")
+    @argument("repositories",
+              type=List[str],
+              positional=False,
+              description="Specify the repository names you want to query (required).")
+    @argument("reload",
+              type=bool,
+              positional=False,
+              description="Specify whether to force reload system cache for SCR (optional, default = False).")
+    def images(self, scr_id: str, repositories: List[str] = [], reload: bool = False) -> int:
         """
-            List Docker images in the workspace.container_registry.
+            List image tags and details of given repositories in an SCR.
         """
-        if not workspace:
-            cprint("Enter a valid workspace", "red")
+        if not repositories:
+            cprint("Enter at least one repository", "red")
             return errno.EIO
         try:
-            resource = trs_resource().load_resource(workspace)
-            ret = resource.container_registry(workspace)
+            resource = trs_resource().load_resource()
+            ret = resource.container_registry(scr_id, repositories, reload)
             images_info = TrsImagesTemplate().create(ret)
-            cprint(f'workspace {workspace} image list:\n----------------------------------------------', 'yellow')
+            cprint(f'SCR ID: {scr_id}\n'
+                   f'Repository list: {repositories}\n'
+                   f'image list:\n----------------------------------------------', 'yellow')
             for img in images_info:
                 cprint(json.dumps(img), 'yellow')
             return 0

{seqslab-cli-3.2.6/python/seqslab/wes → seqslab-cli-3.2.7/python/seqslab/trs}/resource/azure.py

@@ -21,5 +21,5 @@ class AzureResource(BaseResource):
     Azure Compute services provides computation resource in Azure cloud.
     """
 
-    def __init__(self, workspace):
-        super().__init__(workspace)
+    def __init__(self):
+        super().__init__()

{seqslab-cli-3.2.6 → seqslab-cli-3.2.7}/python/seqslab/trs/resource/base.py

@@ -4,7 +4,7 @@ from abc import ABC
 from functools import lru_cache
 from types import TracebackType
 from typing import (
-    Union, Any, Optional, NoReturn, Type, NamedTuple, OrderedDict
+    Union, Any, Optional, NoReturn, Type, NamedTuple, OrderedDict, List
 )
 
 import aiohttp
@@ -40,11 +40,7 @@ class BaseResource(ABC):
     logger = logging.getLogger()
 
     TOKENS_KEY = "tokens"
-    TRS_WORKSPACE_URL = f"https://{API_HOSTNAME}/trs/{__version__}/service-info/workspaces/?backend={{backend}}"
-    TRS_RESOURCES_URL = f"https://{API_HOSTNAME}/trs/{__version__}/service-info/workspaces/{{" \
-                        f"name}}/resources/?backend={{backend}}"
-    TRS_CONTAINER_REGISTRY_URL = f"https://{API_HOSTNAME}/trs/{__version__}/service-info/workspaces/{{" \
-                                 f"name}}/container-registries/?backend={{backend}}"
+    TRS_CONTAINER_REGISTRY_URL = f"https://{API_HOSTNAME}/trs/{__version__}/container-registry/{{scr_id}}"
 
     class Response(NamedTuple):
         status: int
@@ -52,11 +48,7 @@ class BaseResource(ABC):
         body: Any = None
         attrs: OrderedDict = {}
 
-    def __init__(self, workspace):
-        """
-        :param workspace: resource group in Azure, or project in GCS
-        """
-        self._workspace = workspace
+    def __init__(self):
         self.session = aiohttp.ClientSession(raise_for_status=True)
 
     def __enter__(self) -> "BaseResource":
@@ -98,26 +90,15 @@ class BaseResource(ABC):
 
     @staticmethod
     @retry(stop=stop_after_attempt(3), wait=wait_fixed(5), reraise=True)
-    @lru_cache(maxsize=16)
-    def workspace(name) -> dict:
-        ctx = context.get_context()
-        backend = ctx.args.backend
-        token = BaseAuth.get_token().get("tokens").get("access")
-        url = BaseResource.TRS_RESOURCES_URL.format(name=name, backend=backend)
-        with requests.get(url,
-                          headers={"Authorization": f"Bearer {token}"}) as response:
-            if response.status_code not in [requests.codes.ok]:
-                raise requests.HTTPError()
-            return response.json()
-
-    @staticmethod
-    @retry(stop=stop_after_attempt(3), wait=wait_fixed(5), reraise=True)
-    @lru_cache(maxsize=16)
-    def container_registry(name) -> dict:
+    def container_registry(scr_id: str, repositories: List[str], reload: bool) -> dict:
         ctx = context.get_context()
         backend = ctx.args.backend
         token = BaseAuth.get_token().get("tokens").get("access")
-        with requests.get(BaseResource.TRS_CONTAINER_REGISTRY_URL.format(name=name, backend=backend),
+        qp = f'?force={reload}'
+        for repo in repositories:
+            qp += f'&repositories={repo}'
+        print(BaseResource.TRS_CONTAINER_REGISTRY_URL.format(scr_id=scr_id) + f'{qp}')
+        with requests.get(BaseResource.TRS_CONTAINER_REGISTRY_URL.format(scr_id=scr_id) + f'{qp}',
                           headers={"Authorization": f"Bearer {token}"}) as response:
             if response.status_code not in [requests.codes.ok]:
                 raise requests.HTTPError('{"detail":"Workspace must be in SeqsLab supported Azure resource group.",'

{seqslab-cli-3.2.6 → seqslab-cli-3.2.7}/python/seqslab/trs/resource/common.py

@@ -29,14 +29,14 @@ class Factory:
     """Storage backend factory"""
 
     @staticmethod
-    def load_resource(workspace: str) -> Resource:
+    def load_resource() -> Resource:
         backend = context.get_context().args.backend
         name = TRS_RESOURCE_BACKEND.get(backend)
         mod, mem = name.rsplit(".", 1)
         __import__(mod)
         module = sys.modules[mod]
         backend_class = getattr(module, mem)
-        return backend_class(workspace)
+        return backend_class()
 
 
 _factory = Factory()

{seqslab-cli-3.2.6 → seqslab-cli-3.2.7}/python/seqslab/trs/template/base.py

@@ -180,10 +180,10 @@ class TrsImagesTemplate:
     @staticmethod
     def create(container_registry_info: dict) -> dict:
         image_list = []
-        cr = container_registry_info.get('login_server')
+        cr = container_registry_info.get('login_server', None)
         for repo in container_registry_info.get('repositories', []):
             name = repo.get('name')
-            for tag in repo.get('tags'):
+            for tag in repo.get('tags', []):
                 pass
                 image_list.append({
                     "image_type": tag.get('type'),