seqslab-cli 3.3.6__tar.gz → 3.3.8__tar.gz

{seqslab-cli-3.3.6/python/seqslab_cli.egg-info → seqslab-cli-3.3.8}/PKG-INFO

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

{seqslab-cli-3.3.6 → seqslab-cli-3.3.8}/python/seqslab/__init__.py

@@ -21,6 +21,6 @@ name = "seqslab"
 __all__ = []
 
 
-__version__ = "3.3.6"
+__version__ = "3.3.8"
 
 LOGGING = {"DIR_PATH": "/var/log/seqslab"}

{seqslab-cli-3.3.6 → seqslab-cli-3.3.8}/python/seqslab/auth/commands.py

@@ -19,6 +19,7 @@ from requests import HTTPError, request
 from seqslab import settings as api_settings
 from seqslab.auth import __version__, aad_app, azuread
 from seqslab.auth.azuread import API_HOSTNAME
+from seqslab.auth.utils import get_org, request_wrap
 from termcolor import cprint
 
 """
@@ -44,12 +45,10 @@ class BaseAuth:
     AUTHORIZATION_URL = f"https://{API_HOSTNAME}/auth/{__version__}/signin/{{backend}}/"
     ACCESS_TOKEN_URL = f"https://{API_HOSTNAME}/auth/{__version__}/token/{{backend}}/"
     REFRESH_TOKEN_URL = f"https://{API_HOSTNAME}/auth/{__version__}/token/refresh/"
-
-    @staticmethod
-    def _request(url, method, *args, **kwargs):
-        response = request(method, url, **kwargs)
-        response.raise_for_status()
-        return response
+    PROFILE_URL = f"https://{API_HOSTNAME}/auth/{__version__}/profile/"
+    ORGANIZATION_GET_URL = (
+        f"https://{API_HOSTNAME}/management/{__version__}/organizations/{{cus_id}}/"
+    )
 
     def _signin_azure_silent(
         self,
@@ -76,7 +75,7 @@ class BaseAuth:
             )
 
         result.update({"assertion": assertion, "scope": " ".join(scopes)})
-        return self._request(
+        return request_wrap(
             self.ACCESS_TOKEN_URL.format(backend=backend),
             method=self.ACCESS_TOKEN_METHOD,
             params={"secure": True},
@@ -89,7 +88,12 @@ class BaseAuth:
         ).json()
 
     def _signin_azure(
-        self, device_code: bool, daemon: bool, backend: str, proxy: str = None
+        self,
+        device_code: bool,
+        daemon: bool,
+        backend: str,
+        organization_id: str,
+        proxy: str = None,
     ) -> dict:
         result = None
         token_uri = self.ACCESS_TOKEN_URL.format(backend=backend)
@@ -121,7 +125,7 @@ class BaseAuth:
             if not device_code:
                 # obtain authorization uri
                 auth_uri = (
-                    self._request(
+                    request_wrap(
                         self.AUTHORIZATION_URL.format(backend=backend),
                         method=self.ACCESS_TOKEN_METHOD,
                         headers={
@@ -176,8 +180,10 @@ class BaseAuth:
                     raise PermissionError(
                         "{}: {}".format(result["error"], result["error_description"])
                     )
+                if organization_id:
+                    result.update({"cus_id": organization_id})
 
-        return self._request(
+        return request_wrap(
             token_uri,
             method=self.ACCESS_TOKEN_METHOD,
             params={"secure": True} if daemon else None,
@@ -230,7 +236,7 @@ class BaseAuth:
         if arrow.utcnow() >= arrow.get(Auth.tokens["attrs"]["exp"]):
             # expired, refresh token
             proxy = context.get_context().args.proxy
-            with Auth._request(
+            with request_wrap(
                 Auth.REFRESH_TOKEN_URL,
                 method=Auth.ACCESS_TOKEN_METHOD,
                 json={"refresh": Auth.tokens["tokens"]["refresh"]},
@@ -270,13 +276,27 @@ class BaseAuth:
         "daemon",
         type=bool,
         positional=False,
-        description="Sign in for a long-running, non-interactive daemon process (optional).",
+        description="Sign in for a long-running, non-interactive daemon process. (optional).",
         aliases=["d"],
     )
-    def signin(self, device_code: bool = False, daemon: bool = False) -> int:
+    @argument(
+        "organization_id",
+        type=str,
+        positional=False,
+        description="The organization id to signin to (optional).  This argument is valid only for device_code flow.",
+        aliases=["o"],
+    )
+    def signin(
+        self, device_code: bool = False, daemon: bool = False, organization_id=None
+    ) -> int:
         """
         Sign in to the configured authentication backend and obtain API access token.
         """
+        if organization_id and not device_code:
+            logging.warning("Organization_id is only valid for device code flow")
+            cprint("Organization_id is valid only for device cod flow.", "red")
+            return errno.EINVAL
+
         ctx = context.get_context()
         backend = ctx.args.backend
         proxy = ctx.args.proxy
@@ -289,9 +309,10 @@ class BaseAuth:
 
         try:
             method = getattr(self, mname)
-            result = method(device_code, daemon, backend, proxy)
+            result = method(device_code, daemon, backend, organization_id, proxy)
             # store in keyring secret service
             user = getpass.getuser()
+
             keyring.set_password(
                 "net.seqslab.api.tokens.refresh", user, result["tokens"]["refresh"]
             )
@@ -313,7 +334,8 @@ class BaseAuth:
     @command(
         aliases=["daemon"],
         help="Authenticate silently to the platform and obtain API access token. "
-        "This requires that the SeqsLab API app admin consent has been granted.",
+        "This requires that the SeqsLab API app admin consent has been granted and also the user must "
+        "daemon-signin beforehand.",
     )
     @argument(
         "scope",
@@ -362,6 +384,15 @@ class BaseAuth:
             keyring.set_password(
                 "net.seqslab.api.tokens.access", user, result["tokens"]["access"]
             )
+            org_info = get_org(
+                access_token=result["tokens"]["access"],
+                cus_id=self._decode(result["tokens"]["access"])["cus_id"],
+                proxy=proxy,
+            )
+            cprint(
+                f"Daemon process signin to {org_info['name']}",
+                "yellow",
+            )
             return 0
         except ValueError:
             return errno.EINVAL
@@ -381,11 +412,19 @@ class BaseAuth:
         """
         Print platform access token.
         """
+        ctx = context.get_context()
+        proxy = ctx.args.proxy
         token = self.get_token()
         if not token:
             cprint("Not signed in yet")
             return errno.EPERM
 
+        org_info = get_org(
+            access_token=token["tokens"]["access"],
+            cus_id=self._decode(token["tokens"]["access"])["cus_id"],
+            proxy=proxy,
+        )
+        cprint(f"For Organization: {org_info['name']} ({org_info['cus_id']})", "yellow")
         cprint(token["tokens"]["access"], "yellow")
         return 0
 

seqslab-cli-3.3.8/python/seqslab/auth/utils.py

@@ -0,0 +1,46 @@
+# Standard Library
+from functools import lru_cache
+
+from requests import request
+from seqslab.auth import __version__, aad_app, azuread
+from seqslab.auth.azuread import API_HOSTNAME
+
+"""
+Copyright (C) 2024, 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.
+"""
+
+ORGANIZATION_GET_URL = (
+    f"https://{API_HOSTNAME}/management/{__version__}/organizations/{{cus_id}}/"
+)
+
+
+def request_wrap(url, method, *args, **kwargs):
+    response = request(method, url, **kwargs)
+    response.raise_for_status()
+    return response
+
+
+@lru_cache(maxsize=16)
+def get_org(access_token, cus_id, proxy):
+    return request_wrap(
+        ORGANIZATION_GET_URL.format(cus_id=cus_id),
+        method="GET",
+        headers={
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Accept": "application/json",
+            "Authorization": f"Bearer {access_token}",
+        },
+        proxies=proxy,
+    ).json()

{seqslab-cli-3.3.6 → seqslab-cli-3.3.8}/python/seqslab/drs/commands.py

@@ -886,52 +886,6 @@ class BaseDatahub:
 
         return results
 
-    @command(aliases=["deregister"])
-    @argument(
-        "id",
-        type=List[str],
-        positional=False,
-        description="Specify the IDs of the DRS objects that you want to delete "
-        "(optional).",
-    )
-    @argument(
-        "names",
-        type=List[str],
-        positional=False,
-        description="Specify the names of the DRS objects that you want to delete "
-        "(optional).",
-    )
-    @argument(
-        "tags",
-        type=List[str],
-        positional=False,
-        description="Specify the labels of the DRS objects that you want to delete "
-        "(optional).",
-    )
-    def deregister(
-        self,
-        id: List[str] = [],
-        tags: List[str] = [],
-        names: List[str] = [],
-    ) -> int:
-        """
-        Deregister DRS objects by DRS ID, DRS name, or DRS tag.
-        """
-        if not id and not names and not tags:
-            cprint(
-                "Must specify one of the IDs, names or tags to identify DRS objects for deletion",
-                "red",
-            )
-            return errno.ENOENT
-
-        resps = asyncio.run(
-            utils.drs_delete(id, names, tags, query_opts="?backend_content=false")
-        )
-        for r in resps:
-            cprint(r, "yellow")
-
-        return 0
-
     @command(aliases=["clean"])
     @argument(
         "id",
@@ -1535,9 +1489,8 @@ class BaseDatahub:
         add_reads = False
         for sa in rs.SampleSheet.samples:
             if rs.SampleSheet.is_single_end:
-                assert (
-                    sa.to_json().get("Add_Read2_ID") == ""
-                    and sa.to_json().get("Add_Read2_Label") == ""
+                assert not sa.to_json().get("Add_Read2_ID") and not sa.to_json().get(
+                    "Add_Read2_Label"
                 ), "columns Add_Read2_ID and Add_Read2_Label should be blank for single_end sequencer run"
                 if (add_read1_id := sa.to_json().get("Add_Read1_ID")) and (
                     add_read1_label := sa.to_json().get("Add_Read1_Label")

seqslab-cli-3.3.8/python/seqslab/organization/commands.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+# Standard Library
+import errno
+import getpass
+from typing import List
+
+import keyring
+import requests
+import yarl
+from nubia import argument, command, context
+from requests import HTTPError
+from seqslab.auth.commands import BaseAuth as Auth
+from seqslab.auth.utils import get_org
+from seqslab.organization.resource.base import BaseResource
+from termcolor import cprint
+
+"""
+Copyright (C) 2023, 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.
+"""
+
+
+class BaseOrg:
+    @command
+    def list(self, **kwargs) -> int:
+        """
+        List organizations to which the current user belongs
+        """
+        ctx = context.get_context()
+        backend = ctx.args.backend
+
+        try:
+            token = Auth.get_token().get("tokens").get("access")
+            organizations = (
+                BaseResource.request_wrapper(
+                    callback=requests.get,
+                    url=Auth.PROFILE_URL.format(backend=backend),
+                    headers={"Authorization": f"Bearer {token}"},
+                    status=[requests.codes.ok],
+                )
+                .json()
+                .get("organizations")
+            )
+            for index, org_id in enumerate(organizations):
+                values = organizations[org_id]
+                cprint(
+                    f"{values['name']} ({org_id})",
+                    "yellow",
+                )
+        except HTTPError as e:
+            cprint(str(e), "red")
+            return errno.EPROTO
+        else:
+            return 0
+
+    @command
+    @argument(
+        "id",
+        type=str,
+        positional=False,
+        description="Specify an organization ID (required).",
+    )
+    def switch(self, id, **kwargs) -> int:
+        """
+        Switch organizations
+        """
+        ctx = context.get_context()
+        backend = ctx.args.backend
+        proxy = ctx.args.proxy
+        user = getpass.getuser()
+
+        try:
+            token = Auth.get_token().get("tokens").get("access")
+            resp = BaseResource.request_wrapper(
+                callback=requests.get,
+                url=f"{Auth.AUTHORIZATION_URL.format(backend=backend)}{id}/",
+                headers={"Authorization": f"Bearer {token}"},
+                status=[requests.codes.ok],
+            ).json()
+
+            keyring.set_password(
+                "net.seqslab.api.tokens.refresh", user, resp["tokens"]["refresh"]
+            )
+            keyring.set_password(
+                "net.seqslab.api.tokens.access", user, resp["tokens"]["access"]
+            )
+            org_info = get_org(
+                access_token=token, cus_id=Auth._decode(token)["cus_id"], proxy=proxy
+            )
+            cprint(
+                f"The organization you are currently signed into: {org_info['name']}.",
+                "yellow",
+            )
+        except HTTPError as e:
+            cprint(str(e), "red")
+            return errno.EPROTO
+        else:
+            return 0
+
+
+@command
+class Org(BaseOrg):
+    """Organization commands"""
+
+    def __init__(self):
+        super().__init__()

{seqslab-cli-3.3.6 → seqslab-cli-3.3.8}/python/seqslab/runsheet/runsheet.py

@@ -16,18 +16,25 @@ class Run:
         - ``"Run_Name"``
         - ``"Workflow_URL"``
         - ``"Runtimes"``
+        - ``"Run_Schedule_ID``
 
     A run may include multiple samples.  For samples in a Run Sheet, samples with the same Run_Name will be clustered
     as a single run.
     """
 
     def __init__(
-        self, samples: List[Sample], run_name: str, workflow_url: str, runtimes: str
+        self,
+        samples: List[Sample],
+        run_name: str,
+        workflow_url: str,
+        runtimes: str,
+        run_schedule_id: str = None,
     ) -> None:
         self.sample_sheet: Optional[SampleSheet] = None
         self.run_name = run_name
         self.workflow_url = workflow_url
         self.runtimes = runtimes
+        self.run_schedule_id = run_schedule_id
         self.samples = []
         if not workflow_url.endswith("/"):
             raise ValueError(
@@ -40,6 +47,7 @@ class Run:
                     s.get("Run_Name") == self.run_name
                     and s.get("Workflow_URL") == self.workflow_url
                     and s.get("Runtimes") == self.runtimes
+                    and s.get("Run_Schedule_ID") == self.run_schedule_id
                 ):
                     self.samples.append(s)
 
@@ -162,6 +170,7 @@ class RunSheet:
                 sample.get("Run_Name"),
                 sample.get("Workflow_URL"),
                 sample.get("Runtimes"),
+                sample.get("Run_Schedule_ID"),
             )
             rn = sample.get("Run_Name")
             if rsig in runs and rn in run_name_set:
@@ -174,7 +183,7 @@ class RunSheet:
                     f"Inconsistent run_name/run_name_set {rn}/{run_name_set} and run sig/runs {rsig}/{runs.keys()}"
                 )
         for k, v in runs.items():
-            self._runs.append(Run(v, k[0], k[1], k[2]))
+            self._runs.append(Run(v, k[0], k[1], k[2], k[3]))
 
     @property
     def runs(self) -> List:

{seqslab-cli-3.3.6 → seqslab-cli-3.3.8}/python/seqslab/user/commands.py

@@ -149,12 +149,11 @@ class BaseUser:
         if email.find("@") == -1:
             cprint("Please give a legitimate email", "red")
             return errno.ENOENT
-
         ret = backend.add_user(
             email=email,
             roles=roles,
             active=not deactivate,
-            name=name if not name else email.split("@")[0],
+            name=name if name else email.split("@")[0],
         )
         if isinstance(ret, int):
             return ret
@@ -214,7 +213,7 @@ class BaseUser:
         if roles:
             payload["roles"] = roles
         if name:
-            payload["name"] = name
+            payload["username"] = name
         if activate and not deactivate:
             payload["is_active"] = True
         elif deactivate and not activate:

{seqslab-cli-3.3.6 → seqslab-cli-3.3.8}/python/seqslab/wes/commands.py

@@ -19,13 +19,13 @@ from seqslab.auth.commands import BaseAuth
 from seqslab.exceptions import exception_handler
 from seqslab.runsheet.runsheet import Run, RunSheet
 from seqslab.trs.register.common import trs_register
-from seqslab.wes import API_HOSTNAME, __version__
-from seqslab.wes.internal import parameters
 from seqslab.workspace.internal.common import get_factory as get_workspace_factory
 from tenacity import retry, stop_after_attempt, wait_fixed
 from termcolor import cprint
 from tzlocal import get_localzone
 
+from . import API_HOSTNAME, __version__
+from .internal import parameters
 from .resource.common import get_factory
 
 """
@@ -494,38 +494,32 @@ class BaseJobs:
         request_path = f"{working_dir}/{rpath}-request.json"
         wf_info = run.workflow_url.split("versions")[1].strip("/").split("/")
 
-        if not execs:
-            trs_register().load_resource().get_execs_json(
-                workflow_url=run.workflow_url, download_path=execs_path
-            )
+        resource = get_factory().load_resource()
+        if run.run_schedule_id:
+            req = resource.get_schedule(run.run_schedule_id).get("request")
+            params = req.get("workflow_params")
+            backend_params = req.get("workflow_backend_params")
         else:
-            execs_path = f"{working_dir}/{execs}"
 
-        resource = get_factory().load_resource()
-        ops = resource.list_operator_pipelines(page=1, page_size=1000)["results"]
-        opp_w_args = [
-            op["id"]
-            for op in ops
-            for operator in op["operators"]
-            if isinstance(operator, dict) and operator.get("arguments")
-        ]
-        params = parameters.workflow_params(
-            execs_path,
-            run,
-            is_runsheet_template,
-            is_single_end,
-            fq_signature,
-            opp_w_args,
-        )
-        if not isinstance(params, dict):
-            raise Exception(
-                f"Unable to generate workflow_params based on given exec_path, with error code {params}"
+            if not execs:
+                trs_register().load_resource().get_execs_json(
+                    workflow_url=run.workflow_url, download_path=execs_path
+                )
+            else:
+                execs_path = f"{working_dir}/{execs}"
+
+            ops = resource.list_operator_pipelines(page=1, page_size=1000)["results"]
+            opp_w_args = [
+                op["id"]
+                for op in ops
+                for operator in op["operators"]
+                if isinstance(operator, dict) and operator.get("arguments")
+            ]
+            params = parameters.workflow_params(
+                execs_path,
+                opp_w_args,
             )
-
-        request = {
-            "name": run.run_name,
-            "workflow_params": params,
-            "workflow_backend_params": parameters.workflow_backend_params(
+            backend_params = parameters.workflow_backend_params(
                 execs_path,
                 workspace,
                 run.runtimes,
@@ -533,7 +527,22 @@ class BaseJobs:
                 trust,
                 kernel_version,
                 token_lifetime,
-            ),
+            )
+
+        if is_runsheet_template:
+            params = parameters.runsheet_rendering(
+                params, run, fq_signature, is_single_end
+            )
+
+        if not isinstance(params, dict):
+            raise Exception(
+                f"Unable to generate workflow_params based on given exec_path, with error code {params}"
+            )
+
+        request = {
+            "name": run.run_name,
+            "workflow_params": params,
+            "workflow_backend_params": backend_params,
             "workflow_url": run.workflow_url,
             "workflow_type_version": "1.0",
             "workflow_type": wf_info[1],