seqslab-cli 3.3.1__tar.gz → 3.3.2__tar.gz

{seqslab-cli-3.3.1 → seqslab-cli-3.3.2}/LICENSE

@@ -12,6 +12,3 @@ laws and state trade secret laws, punishable by civil and criminal penalties.
 date    2022/02/11
 
 version 3.0.0
-
-
-

{seqslab-cli-3.3.1 → seqslab-cli-3.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: seqslab-cli
-Version: 3.3.1
+Version: 3.3.2
 Summary: Atgenomix SeqsLab Command Line Tool
 Home-page: https://github.com/AnomeGAP/seqslab-cli
 Author: Allen Chang
@@ -43,7 +43,7 @@ Description: <!-- PROJECT SHIELDS -->
         ### Prerequisites
         
         * Python 3.8 or later
-         
+        
         * [keyring](https://pypi.org/project/keyring/)
         * [dbus](https://wiki.freedesktop.org/www/Software/dbus/)
         * [glib](https://docs.gtk.org/glib/)
@@ -75,7 +75,7 @@ Description: <!-- PROJECT SHIELDS -->
           ```bash
           root> exit
           ```
-          
+        
         ### CLI Mode
         
         Through the use of subcommands, you can operate the SeqsLab CLI like any traditional Linux-based command-line utility.
@@ -89,7 +89,7 @@ Description: <!-- PROJECT SHIELDS -->
         ### Basic Commands
         #### Authentication with the SeqsLab API
         
-        Regardless of the mode that you intend to use, you must sign in to authenticate the session. The SeqsLab CLI follows the OAuth 2.0 Device Authorization Grant (external URL) process.  
+        Regardless of the mode that you intend to use, you must sign in to authenticate the session. The SeqsLab CLI follows the OAuth 2.0 Device Authorization Grant (external URL) process.
         
         Example (interactive mode):
         

{seqslab-cli-3.3.1 → seqslab-cli-3.3.2}/README.md

@@ -33,7 +33,7 @@ This package provides a unified command line interface to Atgenomix SeqsLab, a c
 ### Prerequisites
 
 * Python 3.8 or later
- 
+
 * [keyring](https://pypi.org/project/keyring/)
 * [dbus](https://wiki.freedesktop.org/www/Software/dbus/)
 * [glib](https://docs.gtk.org/glib/)
@@ -65,7 +65,7 @@ This mode provides fish-style auto-completion functionality that is user-friendl
   ```bash
   root> exit
   ```
-  
+
 ### CLI Mode
 
 Through the use of subcommands, you can operate the SeqsLab CLI like any traditional Linux-based command-line utility.
@@ -79,7 +79,7 @@ Through the use of subcommands, you can operate the SeqsLab CLI like any traditi
 ### Basic Commands
 #### Authentication with the SeqsLab API
 
-Regardless of the mode that you intend to use, you must sign in to authenticate the session. The SeqsLab CLI follows the OAuth 2.0 Device Authorization Grant (external URL) process.  
+Regardless of the mode that you intend to use, you must sign in to authenticate the session. The SeqsLab CLI follows the OAuth 2.0 Device Authorization Grant (external URL) process.
 
 Example (interactive mode):
 

{seqslab-cli-3.3.1 → seqslab-cli-3.3.2}/python/seqslab/__init__.py

@@ -18,13 +18,9 @@ laws and state trade secret laws, punishable by civil and criminal penalties.
 
 name = "seqslab"
 
-__all__ = [
+__all__ = []
 
-]
 
+__version__ = "3.3.2"
 
-__version__ = "3.3.1"
-
-LOGGING = {
-    "DIR_PATH": "/var/log/seqslab"
-}
+LOGGING = {"DIR_PATH": "/var/log/seqslab"}

{seqslab-cli-3.3.1 → seqslab-cli-3.3.2}/python/seqslab/auth/azuread.py

@@ -1,53 +1,64 @@
 from __future__ import absolute_import, unicode_literals
 
-from typing import TypeVar
-
-import msal
-import environ
+# Standard Library
 import atexit
 import pickle
+from typing import TypeVar
+from urllib.parse import parse_qs
 
-from pydantic import BaseModel
-
+import environ
+import msal
 import seqslab
-from urllib.parse import parse_qs
-from nubia import context
 from msal.oauth2cli.authcode import (
-    _AuthCodeHandler,
     AuthCodeReceiver,
-    _AuthCodeHttpServer6,
+    _AuthCodeHandler,
     _AuthCodeHttpServer,
-    _qs2kv)
+    _AuthCodeHttpServer6,
+    _qs2kv,
+)
+from nubia import context
+from pydantic import BaseModel
 
 env = environ.Env()
 environ.Env.read_env("/etc/seqslab/cli_apps.env")
 
 PRIVATE_NAME = env.str("PRIVATE_NAME", "api")
 API_HOSTNAME = f"{PRIVATE_NAME}.seqslab.net"
-SOCIAL_AUTH_AZURE_KEY = env.str("AZUREAD_OAUTH2_KEY", "b10403db-7700-42c2-996e-116578438579")
+SOCIAL_AUTH_AZURE_KEY = env.str(
+    "AZUREAD_OAUTH2_KEY", "b10403db-7700-42c2-996e-116578438579"
+)
 SOCIAL_AUTH_AZURE_TENANT_ID = env.str("AZUREAD_OAUTH2_TENANT", "organizations")
-SOCIAL_AUTH_AZURE_SCOPE = env.json("AZUREAD_OAUTH2_SCOPE",
-                                   ["email offline_access "
-                                    "https://management.azure.com/user_impersonation"])
-SOCIAL_AUTH_AZURE_SCOPE_APP = env.json("AZUREAD_OAUTH2_SCOPE_APP",
-                                       {"management": ['https://management.azure.com/.default'],
-                                        "storage": ['https://storage.azure.com/.default']})
+SOCIAL_AUTH_AZURE_SCOPE = env.json(
+    "AZUREAD_OAUTH2_SCOPE",
+    ["email offline_access " "https://management.azure.com/user_impersonation"],
+)
+SOCIAL_AUTH_AZURE_SCOPE_APP = env.json(
+    "AZUREAD_OAUTH2_SCOPE_APP",
+    {
+        "management": ["https://management.azure.com/.default"],
+        "storage": ["https://storage.azure.com/.default"],
+    },
+)
 
 http_cache = f"/tmp/{seqslab.name}.{seqslab.__version__}.http_cache"
 try:
     with open(http_cache, "rb") as f:
         persisted_http_cache = pickle.load(f)  # Take a snapshot
 except (
-        FileNotFoundError,
-        pickle.UnpicklingError,  # A corrupted http cache file
+    FileNotFoundError,
+    pickle.UnpicklingError,  # A corrupted http cache file
 ):
     persisted_http_cache = {}  # Recover by starting afresh
 
-atexit.register(lambda: pickle.dump(
-    # When exit, flush it back to the file.
-    # It may occasionally overwrite another process's concurrent write,
-    # but that is fine. Subsequent runs will reach eventual consistency.
-    persisted_http_cache, open(http_cache, "wb")))
+atexit.register(
+    lambda: pickle.dump(
+        # When exit, flush it back to the file.
+        # It may occasionally overwrite another process's concurrent write,
+        # but that is fine. Subsequent runs will reach eventual consistency.
+        persisted_http_cache,
+        open(http_cache, "wb"),
+    )
+)
 
 Client = TypeVar("Client", bound=msal.ClientApplication)
 
@@ -72,7 +83,8 @@ class ClientApp(AuthBaseModel):
                     app_name=seqslab.name,
                     app_version=seqslab.__version__,
                     proxies=proxies,
-                    http_cache=persisted_http_cache)
+                    http_cache=persisted_http_cache,
+                )
             return self.confidential_app
         else:
             if not self.public_app:
@@ -82,7 +94,8 @@ class ClientApp(AuthBaseModel):
                     app_name=seqslab.name,
                     app_version=seqslab.__version__,
                     proxies=proxies,
-                    http_cache=persisted_http_cache)
+                    http_cache=persisted_http_cache,
+                )
             return self.public_app
 
 
@@ -90,24 +103,26 @@ app = ClientApp()
 
 
 class _AuthCodeHandlerEx(_AuthCodeHandler):
-
     def do_POST(self):
-        clen = int(self.headers.get('Content-Length'))
+        clen = int(self.headers.get("Content-Length"))
         body = self.rfile.read(clen)
-        qs = parse_qs(body.decode('utf-8'))
-        if qs.get('code') or qs.get("error"):
+        qs = parse_qs(body.decode("utf-8"))
+        if qs.get("code") or qs.get("error"):
             self.server.auth_response = _qs2kv(qs)
-            template = (self.server.success_template
-                        if "code" in qs else self.server.error_template)
+            template = (
+                self.server.success_template
+                if "code" in qs
+                else self.server.error_template
+            )
             self._send_full_response(
-                template.safe_substitute(**self.server.auth_response))
+                template.safe_substitute(**self.server.auth_response)
+            )
             # NOTE: Don't do self.server.shutdown() here. It'll halt the server.
         else:
             self._send_full_response(self.server.welcome_page)
 
 
 class AuthCodeReceiverEx(AuthCodeReceiver):
-
     def __init__(self, port=None):
         """
         Create a Receiver waiting for incoming auth response.
@@ -118,5 +133,3 @@ class AuthCodeReceiverEx(AuthCodeReceiver):
         address = "127.0.0.1"
         Server = _AuthCodeHttpServer6 if ":" in address else _AuthCodeHttpServer
         self._server = Server((address, port or 0), _AuthCodeHandlerEx)
-
-

{seqslab-cli-3.3.1 → seqslab-cli-3.3.2}/python/seqslab/auth/commands.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+# Standard Library
 import errno
 import getpass
 import json
@@ -13,14 +14,10 @@ import jwt
 import keyring
 import requests
 from keyring.errors import PasswordDeleteError
-from nubia import argument
-from nubia import command
-from nubia import context
-from requests import HTTPError
-from requests import request
+from nubia import argument, command, context
+from requests import HTTPError, request
 from seqslab import settings as api_settings
-from seqslab.auth import aad_app
-from seqslab.auth import azuread, __version__
+from seqslab.auth import __version__, aad_app, azuread
 from seqslab.auth.azuread import API_HOSTNAME
 from termcolor import cprint
 
@@ -55,18 +52,26 @@ class BaseAuth:
         return response
 
     def _signin_azure_silent(
-        self, credential: str, assertion: str, scope: str, backend: str, proxy: str = None
+        self,
+        credential: str,
+        assertion: str,
+        scope: str,
+        backend: str,
+        proxy: str = None,
     ) -> dict:
         scopes = azuread.SOCIAL_AUTH_AZURE_SCOPE_APP.get(scope)
         client = aad_app.load_client(credential=credential)
         result = client.acquire_token_silent(scopes, account=None)
         if not result:
-            logging.info("No suitable token exists in cache. Let's get a new one from AAD.")
+            logging.info(
+                "No suitable token exists in cache. Let's get a new one from AAD."
+            )
             result = client.acquire_token_for_client(scopes=scopes)
 
         if "error" in result:
-            raise PermissionError("{}: {}".format(result["error"],
-                                                  result["error_description"]))
+            raise PermissionError(
+                "{}: {}".format(result["error"], result["error_description"])
+            )
 
         result.update({"assertion": assertion, "scope": " ".join(scopes)})
         return self._request(
@@ -74,9 +79,12 @@ class BaseAuth:
             method=self.ACCESS_TOKEN_METHOD,
             params={"secure": True},
             data=result,
-            headers={"Content-Type": "application/x-www-form-urlencoded",
-                     "Accept": "application/json"},
-            proxies=proxy).json()
+            headers={
+                "Content-Type": "application/x-www-form-urlencoded",
+                "Accept": "application/json",
+            },
+            proxies=proxy,
+        ).json()
 
     def _signin_azure(
         self, device_code: bool, daemon: bool, backend: str, proxy: str = None
@@ -87,7 +95,9 @@ class BaseAuth:
         client = aad_app.load_client()
         accounts = client.get_accounts()
         if accounts:
-            logging.info("Azure AD account(s) exists in cache and proceed with token cache.")
+            logging.info(
+                "Azure AD account(s) exists in cache and proceed with token cache."
+            )
 
             if 1 == len(accounts):
                 chosen = accounts[0]
@@ -102,38 +112,50 @@ class BaseAuth:
             result = client.acquire_token_silent(scopes=scopes, account=chosen)
 
         if result is None:
-            logging.info("No suitable token exists in cache. You must get a new one from AAD.")
+            logging.info(
+                "No suitable token exists in cache. You must get a new one from AAD."
+            )
 
             if not device_code:
                 # obtain authorization uri
                 auth_uri = (
-                    self._request(self.AUTHORIZATION_URL.format(backend=backend),
-                                  method=self.ACCESS_TOKEN_METHOD,
-                                  headers={"Content-Type": "application/x-www-form-urlencoded",
-                                           "Accept": "application/json"},
-                                  params={"format": "json"},
-                                  proxies=proxy)
-                        .json()
-                        .get("url")
+                    self._request(
+                        self.AUTHORIZATION_URL.format(backend=backend),
+                        method=self.ACCESS_TOKEN_METHOD,
+                        headers={
+                            "Content-Type": "application/x-www-form-urlencoded",
+                            "Accept": "application/json",
+                        },
+                        params={"format": "json"},
+                        proxies=proxy,
+                    )
+                    .json()
+                    .get("url")
                 )
 
                 with azuread.AuthCodeReceiverEx(port=0) as receiver:
                     # hardcode http://localhost here as msal also hardcodes that
                     redirect_uri = f"http://localhost:{receiver.get_port()}"
-                    auth_uri = re.sub(r"(redirect_uri=)[^&]+",
-                                      r"\1" + quote(redirect_uri, safe=""),
-                                      auth_uri)
+                    auth_uri = re.sub(
+                        r"(redirect_uri=)[^&]+",
+                        r"\1" + quote(redirect_uri, safe=""),
+                        auth_uri,
+                    )
                     auth_uri = re.sub(r"prompt=[^&]+&", "", auth_uri)
                     result = receiver.get_auth_response(
                         auth_uri=auth_uri,
                         timeout=60,
                         success_template="You have signed in with your Microsoft "
-                                         "account on your device. "
-                                         "You may now close this window.")
+                        "account on your device. "
+                        "You may now close this window.",
+                    )
 
                     if "error" in result:
-                        raise PermissionError("{}: {}".format(
-                            result["error"], result["error_description"]))
+                        raise PermissionError(
+                            "{}: {}".format(
+                                result["error"], result["error_description"]
+                            )
+                        )
 
                 token_uri = self.AUTHORIZATION_URL.format(backend=backend)
                 result.update({"redirect_uri": redirect_uri})
@@ -141,31 +163,39 @@ class BaseAuth:
                 flow = client.initiate_device_flow(scopes=scopes)
                 if "user_code" not in flow:
                     raise ValueError(
-                        "Unable to create device flow. Err: %s" % json.dumps(flow, indent=4))
+                        "Unable to create device flow. Err: %s"
+                        % json.dumps(flow, indent=4)
+                    )
 
                 cprint(flow["message"], "red")
                 # input("Press Enter after signing in from another device to proceed, CTRL+C to abort.")
                 result = client.acquire_token_by_device_flow(flow)
                 if "error" in result:
-                    raise PermissionError("{}: {}".format(
-                        result["error"], result["error_description"]))
+                    raise PermissionError(
+                        "{}: {}".format(result["error"], result["error_description"])
+                    )
 
         return self._request(
             token_uri,
             method=self.ACCESS_TOKEN_METHOD,
             params={"secure": True} if daemon else None,
             data=result,
-            headers={"Content-Type": "application/x-www-form-urlencoded",
-                     "Accept": "application/json"},
-            proxies=proxy).json()
+            headers={
+                "Content-Type": "application/x-www-form-urlencoded",
+                "Accept": "application/json",
+            },
+            proxies=proxy,
+        ).json()
 
     @staticmethod
     def _decode(token) -> dict:
-        attrs = jwt.decode(token,
-                           key=api_settings.JWT_VERIFYING_KEY,
-                           algorithms=[api_settings.JWT_ALGORITHM],
-                           verify=True,
-                           options={"verify_aud": False, "verify_exp": False})
+        attrs = jwt.decode(
+            token,
+            key=api_settings.JWT_VERIFYING_KEY,
+            algorithms=[api_settings.JWT_ALGORITHM],
+            verify=True,
+            options={"verify_aud": False, "verify_exp": False},
+        )
         if "exp" not in attrs:
             attrs["exp"] = 0
         return attrs
@@ -184,47 +214,63 @@ class BaseAuth:
             try:
                 attrs = Auth._decode(access)
             except jwt.exceptions.ExpiredSignatureError:
-                Auth.tokens.update({"tokens": {"refresh": refresh, "access": None},
-                                    "attrs": {"exp": 0}})
+                Auth.tokens.update(
+                    {
+                        "tokens": {"refresh": refresh, "access": None},
+                        "attrs": {"exp": 0},
+                    }
+                )
             else:
-                Auth.tokens.update({"tokens": {"refresh": refresh, "access": access},
-                                    "attrs": attrs})
+                Auth.tokens.update(
+                    {"tokens": {"refresh": refresh, "access": access}, "attrs": attrs}
+                )
 
         if arrow.utcnow() >= arrow.get(Auth.tokens["attrs"]["exp"]):
             # expired, refresh token
             proxy = context.get_context().args.proxy
-            with Auth._request(Auth.REFRESH_TOKEN_URL,
-                               method=Auth.ACCESS_TOKEN_METHOD,
-                               json={"refresh": Auth.tokens["tokens"]["refresh"]},
-                               headers={"Content-Type": "application/json",
-                                        "Accept": "application/json"},
-                               proxies=proxy) as response:
+            with Auth._request(
+                Auth.REFRESH_TOKEN_URL,
+                method=Auth.ACCESS_TOKEN_METHOD,
+                json={"refresh": Auth.tokens["tokens"]["refresh"]},
+                headers={
+                    "Content-Type": "application/json",
+                    "Accept": "application/json",
+                },
+                proxies=proxy,
+            ) as response:
                 if response.status_code != requests.codes.ok:
                     Auth.tokens.clear()
                     return None
 
                 result = response.json()
-                Auth.tokens['tokens'].update(result)
+                Auth.tokens["tokens"].update(result)
                 Auth.tokens.update({"attrs": Auth._decode(result["access"])})
-                keyring.set_password("net.seqslab.api.tokens.access", user,
-                                     result["access"])
+                keyring.set_password(
+                    "net.seqslab.api.tokens.access", user, result["access"]
+                )
 
         return Auth.tokens
 
     """Authentication command help"""
 
-    @command(aliases=["login"],
-             help="Authenticate to the platform and obtain API access token.")
-    @argument("device_code",
-              type=bool,
-              positional=False,
-              description="Use the device authorization grant flow (optional).",
-              aliases=["i"])
-    @argument("daemon",
-              type=bool,
-              positional=False,
-              description="Sign in for a long-running, non-interactive daemon process (optional).",
-              aliases=["d"])
+    @command(
+        aliases=["login"],
+        help="Authenticate to the platform and obtain API access token.",
+    )
+    @argument(
+        "device_code",
+        type=bool,
+        positional=False,
+        description="Use the device authorization grant flow (optional).",
+        aliases=["i"],
+    )
+    @argument(
+        "daemon",
+        type=bool,
+        positional=False,
+        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:
         """
         Sign in to the configured authentication backend and obtain API access token.
@@ -244,10 +290,12 @@ class BaseAuth:
             result = method(device_code, daemon, backend, proxy)
             # store in keyring secret service
             user = getpass.getuser()
-            keyring.set_password("net.seqslab.api.tokens.refresh", user,
-                                 result["tokens"]["refresh"])
-            keyring.set_password("net.seqslab.api.tokens.access", user,
-                                 result["tokens"]["access"])
+            keyring.set_password(
+                "net.seqslab.api.tokens.refresh", user, result["tokens"]["refresh"]
+            )
+            keyring.set_password(
+                "net.seqslab.api.tokens.access", user, result["tokens"]["access"]
+            )
             return 0
         except ValueError:
             return errno.EINVAL
@@ -260,14 +308,18 @@ class BaseAuth:
             cprint(err, "red")
             return errno.ECANCELED
 
-    @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.")
-    @argument("scope",
-              type=str,
-              positional=False,
-              description="Specify the scope of the application permission requested (default = management).",
-              choices=["management", "storage"])
+    @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.",
+    )
+    @argument(
+        "scope",
+        type=str,
+        positional=False,
+        description="Specify the scope of the application permission requested (default = management).",
+        choices=["management", "storage"],
+    )
     def daemon(self, scope: str = "management") -> int:
         """
         Sign in silently to the configured authentication backend and obtain API access token.
@@ -284,7 +336,7 @@ class BaseAuth:
             return errno.ENODEV
 
         if len(Auth.tokens):
-            assertion = Auth.tokens["tokens"].get('access')
+            assertion = Auth.tokens["tokens"].get("access")
             credential = Auth.tokens["attrs"].get("scrt")
         else:
             # load from Keyring secret service
@@ -302,10 +354,12 @@ class BaseAuth:
             method = getattr(self, mname)
             result = method(credential, assertion, scope, backend, proxy)
             # store in keyring secret service
-            keyring.set_password("net.seqslab.api.tokens.refresh", user,
-                                 result["tokens"]["refresh"])
-            keyring.set_password("net.seqslab.api.tokens.access", user,
-                                 result["tokens"]["access"])
+            keyring.set_password(
+                "net.seqslab.api.tokens.refresh", user, result["tokens"]["refresh"]
+            )
+            keyring.set_password(
+                "net.seqslab.api.tokens.access", user, result["tokens"]["access"]
+            )
             return 0
         except ValueError:
             return errno.EINVAL

{seqslab-cli-3.3.1 → seqslab-cli-3.3.2}/python/seqslab/cli.py

@@ -16,12 +16,12 @@ copies by sale, rental, lease or lending are violations of federal copyright
 laws and state trade secret laws, punishable by civil and criminal penalties.
 """
 
-import sys
+# Standard Library
 import signal
+import sys
 
 from nubia import Nubia, Options
-
-from seqslab import auth, drs, wes, trs, workspace, user, role, organization, scr
+from seqslab import auth, drs, organization, role, scr, trs, user, wes, workspace
 from seqslab.plugin import SQLBPlugin
 
 
@@ -30,7 +30,7 @@ def signal_handler(sig, frame):
     sys.stderr.write(msg)
     ans = input()
 
-    if ans == 'y':
+    if ans == "y":
         print("")
         exit(1)
     else:
@@ -47,8 +47,7 @@ def main():
         command_pkgs=[auth, drs, wes, trs, workspace, user, role, organization, scr],
         plugin=plugin,
         options=Options(
-            persistent_history=False,
-            auto_execute_single_suggestions=False
+            persistent_history=False, auto_execute_single_suggestions=False
         ),
     )
     sys.exit(shell.run())

{seqslab-cli-3.3.1 → seqslab-cli-3.3.2}/python/seqslab/context.py

@@ -1,8 +1,6 @@
 #!/usr/bin/env python3
 
-from nubia import context
-from nubia import exceptions
-from nubia import eventbus
+from nubia import context, eventbus, exceptions
 
 
 class SQLBContext(context.Context):

{seqslab-cli-3.3.1 → seqslab-cli-3.3.2}/python/seqslab/drs/__init__.py

@@ -5,9 +5,7 @@ environ.Env.read_env("/etc/seqslab/cli_apps.env")
 
 name = "drs"
 
-__all__ = [
-
-]
+__all__ = []
 
 __version__ = "v1"