haplohub-cli 0.0.1__py3-none-any.whl

haplohub_cli/__init__.py

@@ -0,0 +1,3 @@
+from ._version import __version__
+
+__all__ = ["__version__"]

haplohub_cli/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.0.1'
+__version_tuple__ = version_tuple = (0, 0, 1)

haplohub_cli/auth/auth.py

@@ -0,0 +1,42 @@
+import webbrowser
+
+import click
+
+from haplohub_cli.auth.auth0_client import auth0_client
+from haplohub_cli.auth.auth_web_server import AuthWebServer
+from haplohub_cli.config.config_manager import config_manager
+from haplohub_cli.core import ensure_config_dir
+from haplohub_cli.core.network import check_port_available
+
+
+def token_login(refresh_token: str):
+    credentials = auth0_client.exchange_refresh_token(refresh_token)
+
+    click.echo("Successfully authenticated with HaploHub.")
+    auth0_client.token_storage.store_credentials(credentials)
+
+
+def interactive_login():
+    ensure_config_dir()
+
+    if not check_port_available(config_manager.config.redirect_port):
+        click.echo(
+            f"Port {config_manager.config.redirect_port} is already in use. Please ensure it is free and try again.\n"
+            f"Use `lsof -i4TCP:{config_manager.config.redirect_port} -sTCP:LISTEN -P -n` to find the process using the port."
+        )
+        exit(1)
+
+    auth_request = auth0_client.init_auth_request()
+    auth_url = auth_request.auth_url
+
+    click.echo(
+        f"Your browser has been opened to authenticate with HaploHub.\n\n    {auth_url[0 : auth_url.find('?')] + '...'}\n"
+    )
+    webbrowser.open(auth_url)
+
+    auth_web_server = AuthWebServer(config_manager.config.redirect_port)
+    auth_code = auth_web_server.handle_request()
+    credentials = auth_request.exchange_code(auth_code)
+
+    click.echo("Successfully authenticated with HaploHub.")
+    auth0_client.token_storage.store_credentials(credentials)

haplohub_cli/auth/auth0_client.py

@@ -0,0 +1,104 @@
+import base64
+import hashlib
+import os
+
+from requests import Session
+
+from haplohub_cli.auth.token_storage import TokenStorage, token_storage
+from haplohub_cli.config.config_manager import config_manager
+
+
+class AuthRequest:
+    def __init__(
+        self,
+        client: "Auth0Client",
+        scopes: list[str],
+    ):
+        self.client = client
+        self.scopes = scopes
+        self.code_verifier, self.code_challenge = self.generate_code_verifier()
+
+    @property
+    def auth_url(self):
+        return (
+            f"https://{self.client.domain}/authorize"
+            f"?client_id={self.client.client_id}"
+            f"&response_type=code"
+            f"&redirect_uri={self.client.redirect_uri}"
+            f"&scope={' '.join(self.scopes)}"
+            f"&code_challenge={self.code_challenge}"
+            f"&code_challenge_method=S256"
+            f"&audience={self.client.audience}"
+        )
+
+    def generate_code_verifier(self):
+        verifier = base64.urlsafe_b64encode(os.urandom(32)).decode("utf-8").rstrip("=")
+        challenge = hashlib.sha256(verifier.encode("utf-8")).digest()
+        challenge = base64.urlsafe_b64encode(challenge).decode("utf-8").rstrip("=")
+        return verifier, challenge
+
+    def exchange_code(self, code: str):
+        return self.client.exchange_code(code, self.code_verifier)
+
+
+class Auth0Client:
+    http = Session()
+
+    def __init__(self, token_storage: TokenStorage, domain: str, client_id: str, audience: str, redirect_uri: str):
+        self.token_storage = token_storage
+        self.domain = domain
+        self.client_id = client_id
+        self.audience = audience
+        self.redirect_uri = redirect_uri
+
+    def init_auth_request(self, scopes: list[str] = ("openid", "profile", "email")):
+        return AuthRequest(client=self, scopes=scopes)
+
+    def exchange_refresh_token(self, refresh_token: str):
+        return self._make_request(
+            "oauth/token",
+            "POST",
+            json={
+                "grant_type": "refresh_token",
+                "client_id": self.client_id,
+                "refresh_token": refresh_token,
+                "audience": self.audience,
+            },
+        )
+
+    def exchange_code(self, code: str, code_verifier: str):
+        return self._make_request(
+            "oauth/token",
+            "POST",
+            json={
+                "grant_type": "authorization_code",
+                "client_id": self.client_id,
+                "code": code,
+                "redirect_uri": self.redirect_uri,
+                "code_verifier": code_verifier,
+                "audience": self.audience,
+            },
+        )
+
+    def get_user_info(self):
+        return self._make_request("userinfo", "GET")
+
+    def _make_request(self, path: str, method: str, data: dict = None, json: dict = None):
+        url = f"https://{self.domain}/{path}"
+
+        headers = None
+        if self.token_storage.credentials_exist:
+            headers = {"Authorization": f"Bearer {self.token_storage.get_access_token()}"}
+
+        response = self.http.request(method, url, headers=headers, data=data, json=json)
+        response.raise_for_status()
+        return response.json()
+
+
+auth0_client = Auth0Client(
+    token_storage=token_storage,
+    domain=config_manager.config.auth0_domain,
+    client_id=config_manager.config.auth0_client_id,
+    audience=config_manager.config.auth0_audience,
+    redirect_uri=config_manager.config.auth0_redirect_uri,
+)

haplohub_cli/auth/auth_web_server.py

@@ -0,0 +1,43 @@
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from typing import Any
+from urllib.parse import parse_qs, urlparse
+
+HTML_SNIPPET = """
+<html>
+    <body>
+        <h1>Authentication successful!</h1>
+        <p>
+            You can now close this window.
+        </p>
+    </body>
+</html>
+"""
+
+
+class AuthHandler(BaseHTTPRequestHandler):
+    def log_message(self, format: str, *args: Any) -> None:
+        # Suppress logging
+        pass
+
+    def do_GET(self):
+        query = urlparse(self.path).query
+        params = parse_qs(query)
+        if "code" in params:
+            self.server.last_auth_code = params["code"][0]
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html")
+            self.end_headers()
+            self.wfile.write(HTML_SNIPPET.encode("utf-8"))
+
+
+class AuthWebServer:
+    def __init__(self, port: int):
+        self.port = port
+        self.server = HTTPServer(
+            ("localhost", self.port),
+            AuthHandler,
+        )
+
+    def handle_request(self):
+        self.server.handle_request()
+        return self.server.last_auth_code

haplohub_cli/auth/tests/test_auth_web_server.py

@@ -0,0 +1,22 @@
+from threading import Timer
+from unittest import TestCase
+
+import requests
+
+from haplohub_cli.auth.auth_web_server import AuthWebServer
+
+
+class AuthWebServerTestCase(TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.port = 60000
+        cls.auth_code = "qwerty123456"
+        cls.instance = AuthWebServer(cls.port)
+
+    def test_auth_web_server_should_return_auth_code_from_redirect_uri(self):
+        Timer(0.01, self._send_request).start()
+        auth_code = self.instance.handle_request()
+        self.assertEqual(auth_code, self.auth_code)
+
+    def _send_request(self):
+        requests.get(f"http://localhost:{self.port}/?code={self.auth_code}")

haplohub_cli/auth/tests/test_token_storage.py

@@ -0,0 +1,43 @@
+import json
+
+from pyfakefs.fake_filesystem_unittest import TestCase
+
+from haplohub_cli.auth.token_storage import TokenStorage
+
+
+class TokenStorageTestCase(TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.setUpClassPyfakefs()
+        cls.instance = TokenStorage("/tmp/test_token_storage.json")
+
+    def test_credentials_exist_should_return_false_when_file_does_not_exist(self):
+        self.assertFalse(self.instance.credentials_exist)
+
+    def test_credentials_exist_should_return_true_when_file_exists(self):
+        with open(self.instance.token_file, "w"):
+            pass
+
+        self.assertTrue(self.instance.credentials_exist)
+
+    def test_store_credentials_should_save_credentials_to_file(self):
+        creds = {"test": True}
+
+        self.instance.store_credentials(creds)
+
+        with open(self.instance.token_file, "r") as f:
+            self.assertEqual(json.load(f), creds)
+
+    def test_get_credentials_should_return_credentials_from_file(self):
+        creds = {"test": True}
+
+        self.instance.store_credentials(creds)
+
+        self.assertEqual(self.instance.get_credentials(), creds)
+
+    def test_get_access_token_should_return_access_token_from_credentials(self):
+        creds = {"access_token": "123456"}
+
+        self.instance.store_credentials(creds)
+
+        self.assertEqual(self.instance.get_access_token(), "123456")

haplohub_cli/auth/token_storage.py

@@ -0,0 +1,27 @@
+import json
+from genericpath import exists
+
+from haplohub_cli import settings
+
+
+class TokenStorage:
+    def __init__(self, token_file: str):
+        self.token_file = token_file
+
+    @property
+    def credentials_exist(self):
+        return exists(self.token_file)
+
+    def store_credentials(self, credentials: dict):
+        with open(self.token_file, "w") as f:
+            json.dump(credentials, f)
+
+    def get_credentials(self):
+        with open(self.token_file, "r") as f:
+            return json.load(f)
+
+    def get_access_token(self):
+        return self.get_credentials()["access_token"]
+
+
+token_storage = TokenStorage(settings.CREDENTIALS_FILE)

haplohub_cli/cli.py

@@ -0,0 +1,35 @@
+import click
+
+from haplohub_cli.commands import cohort, config, file, login, version
+from haplohub_cli.commands.model import model
+from haplohub_cli.formatters.formatter_registry import formatter_registry
+
+
+@click.group()
+def cli():
+    """
+    HaploHub CLI
+
+    To get started, take a look at the documentation:
+    https://github.com/haplotypelabs/haplohub-cli
+    """
+    pass
+
+
+@cli.result_callback()
+def formatter_callback(result):
+    if result is None or not formatter_registry.has_formatter(type(result)):
+        return
+
+    formatter_registry.format(result)
+
+
+cli.add_command(config.config)
+cli.add_command(login.cmd)
+cli.add_command(version.cmd)
+cli.add_command(cohort.cohort)
+cli.add_command(file.file)
+cli.add_command(model.model)
+
+if __name__ == "__main__":
+    cli()

haplohub_cli/commands/cohort.py

@@ -0,0 +1,33 @@
+import click
+from haplohub import CreateCohortRequest
+
+from haplohub_cli.core.api.client import client
+
+
+@click.group()
+def cohort():
+    """
+    Manage cohorts
+    """
+    pass
+
+
+@cohort.command()
+def list():
+    return client.cohort.list_cohorts()
+
+
+@cohort.command()
+@click.argument("name")
+@click.option("--description", type=str, required=False)
+def create(name, description=None):
+    description = description or ""
+
+    request = CreateCohortRequest(name=name, description=description)
+    return client.cohort.create_cohort(request)
+
+
+@cohort.command()
+@click.argument("id")
+def delete(id):
+    return client.cohort.delete_cohort(id)

haplohub_cli/commands/config.py

@@ -0,0 +1,40 @@
+import click
+
+from haplohub_cli.config.config_manager import config_manager
+from haplohub_cli.config.environments import ENVIRONMENTS
+
+
+@click.group()
+def config():
+    """
+    Manage configuration
+    """
+    pass
+
+
+@config.command()
+def show():
+    return config_manager.config
+
+
+@config.command()
+@click.argument("key")
+@click.argument("value")
+def set(key, value):
+    setattr(config_manager.config, key, value)
+    config_manager.save()
+    return config_manager.config
+
+
+@config.command()
+@click.argument("environment", type=click.Choice(ENVIRONMENTS.keys()))
+def switch(environment):
+    config_manager.switch_environment(environment)
+    return config_manager.config
+
+
+@config.command()
+def reset():
+    config_manager.reset()
+    config_manager.save()
+    return config_manager.config

haplohub_cli/commands/file.py

@@ -0,0 +1,84 @@
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from posixpath import basename
+from uuid import uuid4
+
+import click
+import requests
+from haplohub import CreateUploadRequestRequest, FileInfo, UploadType
+from rich.progress import Progress
+
+from haplohub_cli.core.api.client import client
+from haplohub_cli.core.checksum import calculate_checksum
+
+
+@click.group()
+def file():
+    """
+    Manage files
+    """
+    pass
+
+
+@file.command()
+@click.option("--cohort", "-c", type=click.STRING, required=True)
+@click.option("--path", "-p", type=click.STRING, required=False)
+@click.option("--recursive", "-r", is_flag=True, required=False)
+def list(cohort: str, path: str = None, recursive: bool = False):
+    return client.file.list_files(
+        cohort,
+        recursive=recursive,
+        path=path,
+    )
+
+
+@file.command()
+@click.argument("filenames", nargs=-1, type=click.Path(exists=True, dir_okay=False), required=True)
+@click.option("--cohort", "-c", type=click.STRING, required=True)
+@click.option("--file-type", "-t", type=click.Choice(UploadType), required=True)
+@click.option("--sample", "-s", type=click.STRING, required=False)
+@click.option("--member", "-m", type=click.STRING, required=False)
+def upload(cohort: str, filenames: tuple[str, ...], file_type: UploadType = None, sample: str = None, member: str = None):
+    checksums = {}
+    file_map = {}
+
+    for full_path in filenames:
+        file_name = basename(full_path)
+        checksums[file_name] = calculate_checksum(full_path)
+        file_map[file_name] = full_path
+
+    request = CreateUploadRequestRequest(
+        upload_request_id=str(uuid4()),
+        file_type=file_type,
+        sample_id=sample,
+        member_id=member,
+        files=[
+            FileInfo(
+                file_path=file_name,
+                md5_hash=checksums[file_name],
+            )
+            for file_name in file_map.keys()
+        ],
+    )
+
+    response = client.upload.create_upload_request(cohort, request).actual_instance
+
+    if response.status == "error":
+        return response
+
+    with Progress() as progress:
+        uploading = progress.add_task("Uploading files", total=len(response.result.upload_links))
+
+        with ThreadPoolExecutor(max_workers=8) as executor:
+            futures = [
+                executor.submit(
+                    requests.put,
+                    file.signed_url,
+                    data=open(file_map[file.original_file_path], "rb").read(),
+                    headers={"Content-MD5": checksums[file.original_file_path]},
+                )
+                for file in response.result.upload_links
+            ]
+
+            for future in as_completed(futures):
+                future.result().raise_for_status()
+                progress.update(uploading, advance=1)

haplohub_cli/commands/login.py

@@ -0,0 +1,17 @@
+from typing import Optional
+
+import click
+
+from haplohub_cli.auth.auth import interactive_login, token_login
+
+
+@click.command(name="login")
+@click.option("--token", type=str, help="Token")
+def cmd(token: Optional[str] = None):
+    """
+    Login to HaploHub
+    """
+    if token is None:
+        interactive_login()
+    else:
+        token_login(token)

haplohub_cli/commands/model/model.py

@@ -0,0 +1,62 @@
+import subprocess
+
+import click
+from haplohub import CreateModelRequest, PushModelRequest
+
+from haplohub_cli.core.api.client import client
+
+from . import run
+
+
+@click.group()
+def model():
+    """
+    Manage models
+    """
+    pass
+
+
+@model.command()
+def list():
+    """
+    List all models.
+    """
+    return client.model.list_models()
+
+
+@model.command()
+def build():
+    """
+    Build a model.
+    """
+    subprocess.run(["cog", "build"])
+
+
+@model.command()
+@click.argument("name")
+def push(name, tag: str = None):
+    models = client.model.list_models(name=name)
+    if models.total_count == 0:
+        model = client.model.create_model(CreateModelRequest(name=name))
+    else:
+        model = models.items[0]
+
+    response = client.model.push_model(model.id, PushModelRequest(version="latest"))
+    push_request = response.result
+
+    subprocess.run(
+        ["docker", "login", "-u", "oauth2accesstoken", "--password-stdin", f"https://{push_request.registry_host}"],
+        input=push_request.push_token.encode(),
+        check=True,
+    )
+    subprocess.run(["cog", "push", f"{push_request.registry_host}/{push_request.image_path}"], check=True)
+
+    # TODO: Push request contains repository URL and temporary credentials.
+    # TODO: Authenticate to the customer's repository using temporary credentials.
+    # TODO: Use `cog push {repostiroty_url}/{name}` to push the model to the customer's repository.
+    # docker login -u oauth2accesstoken --password {push_request.push_token} {push_request.repository_url}
+    # cog push {push_request.repository_url}/{name}
+    pass
+
+
+model.add_command(run.run)

haplohub_cli/commands/model/run.py

@@ -0,0 +1,63 @@
+import click
+
+from haplohub_cli.core.api.client import client
+
+
+@click.group()
+def run():
+    """
+    Manage model runs
+    """
+    pass
+
+
+@run.command()
+@click.argument("model_id")
+@click.option("--input-file", "-i", type=click.STRING, required=False)
+@click.option("--input-data", "-I", type=click.STRING, required=False)
+@click.option("--wait", "-w", is_flag=True)
+def create(model_id, input_file: str = None, input_data: str = None, wait: bool = False):
+    """
+    1. Fetches model information.
+    2. Ensures input data is valid.
+    3. Call an API to run the model with input data.
+    4. Pass wait flag to wait for the job to finish.
+      4.1 Poll the job run status until it's finished.
+    5. Return either the job run metadata or the job results.
+    """
+    pass
+
+
+@run.command()
+def list():
+    return client.run.list_runs()
+
+
+@run.command()
+@click.argument("run_id")
+def status(run_id):
+    """
+    1. Fetches job run information.
+    2. Return the job run status.
+    """
+    pass
+
+
+@run.command()
+@click.argument("run_id")
+def logs(run_id):
+    """
+    1. Fetches job run logs.
+    2. Return the job run logs.
+    """
+    pass
+
+
+@run.command()
+@click.argument("run_id")
+def results(run_id):
+    """
+    1. Fetches job run results.
+    2. Return the job run results.
+    """
+    pass

haplohub_cli/commands/version.py

@@ -0,0 +1,11 @@
+import click
+
+from haplohub_cli import __version__
+
+
+@click.command(name="version")
+def cmd():
+    """
+    Get the version of the HaploHub CLI
+    """
+    click.echo(f"HaploHub CLI version {__version__}")

haplohub_cli/config/config.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel
+
+
+class Config(BaseModel):
+    api_url: str
+    redirect_port: int
+    auth0_domain: str
+    auth0_client_id: str
+    auth0_audience: str
+
+    @property
+    def auth0_redirect_uri(self):
+        return f"http://localhost:{self.redirect_port}/"

haplohub_cli/config/config_manager.py

@@ -0,0 +1,57 @@
+from genericpath import exists
+
+from haplohub_cli.config.config import Config
+
+from .. import settings
+from .environments import ENVIRONMENTS
+
+defaults = Config(
+    redirect_port=8088,
+    **ENVIRONMENTS["prod"],
+)
+
+
+class ConfigManager:
+    def __init__(self, config_file: str):
+        self.config_file = config_file
+        self._config = None
+        self.read_config()
+
+    def init_config(self):
+        if exists(self.config_file):
+            return
+
+        self._config = defaults
+        self.save()
+
+    def read_config(self):
+        if not exists(self.config_file):
+            self.init_config()
+
+        self._config = Config.parse_file(self.config_file)
+
+    def switch_environment(self, environment: str):
+        if environment not in ENVIRONMENTS:
+            raise ValueError(f"Invalid environment: {environment}")
+
+        for key, value in ENVIRONMENTS[environment].items():
+            setattr(self._config, key, value)
+
+        self.save()
+
+    def save(self):
+        with open(self.config_file, "wt") as f:
+            f.write(self._config.json(indent=4))
+
+    def reset(self):
+        self._config = defaults
+        self.save()
+
+    @property
+    def config(self):
+        if self._config is None:
+            self.read_config()
+        return self._config
+
+
+config_manager = ConfigManager(config_file=settings.CONFIG_FILE)

haplohub_cli/config/environments.py

@@ -0,0 +1,20 @@
+ENVIRONMENTS = {
+    "local": {
+        "auth0_domain": "dev-42a7qv136prmsazj.us.auth0.com",
+        "auth0_client_id": "QHC6QYwzm9UW9fty7e5mno3AJrcjV5MY",
+        "auth0_audience": "http://localhost:3000/api/",
+        "api_url": "http://localhost:8000",
+    },
+    "stage": {
+        "auth0_domain": "dev-42a7qv136prmsazj.us.auth0.com",
+        "auth0_client_id": "5u4nnf7lwKtzH1sGxBm8AtM25FJMiYGm",
+        "auth0_audience": "https://stage.haplohub.com/api/",
+        "api_url": "https://stage.haplohub.com",
+    },
+    "prod": {
+        "auth0_domain": "dev-42a7qv136prmsazj.us.auth0.com",
+        "auth0_client_id": "TRi894X7yV3e8EOpNVrDdvQbRvYnjibH",
+        "auth0_audience": "https://haplohub.com/api/",
+        "api_url": "https://haplohub.com",
+    },
+}

haplohub_cli/core/__init__.py

@@ -0,0 +1,7 @@
+import os
+
+from haplohub_cli import settings
+
+
+def ensure_config_dir():
+    os.makedirs(settings.CONFIG_DIR, exist_ok=True)

haplohub_cli/core/api/client.py

@@ -0,0 +1,45 @@
+from functools import cached_property
+
+from haplohub import (
+    ApiClient,
+    CohortApi,
+    Configuration,
+    FileApi,
+    ModelApi,
+    UploadApi,
+)
+
+from haplohub_cli import settings
+from haplohub_cli.auth.token_storage import TokenStorage
+from haplohub_cli.config.config_manager import config_manager
+
+
+class Client:
+    token_storage = TokenStorage(settings.CREDENTIALS_FILE)
+
+    @cached_property
+    def client(self):
+        config = Configuration(
+            host=config_manager.config.api_url,
+            access_token=self.token_storage.get_access_token(),
+        )
+        return ApiClient(config)
+
+    @cached_property
+    def cohort(self):
+        return CohortApi(self.client)
+
+    @cached_property
+    def file(self):
+        return FileApi(self.client)
+
+    @cached_property
+    def upload(self):
+        return UploadApi(self.client)
+
+    @cached_property
+    def model(self):
+        return ModelApi(self.client)
+
+
+client = Client()

haplohub_cli/core/checksum.py

@@ -0,0 +1,6 @@
+from base64 import b64encode
+from hashlib import md5
+
+
+def calculate_checksum(file_path: str) -> str:
+    return b64encode(md5(open(file_path, "rb").read()).digest()).decode("utf-8")

haplohub_cli/core/network.py

@@ -0,0 +1,6 @@
+import socket
+
+
+def check_port_available(port: int):
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        return s.connect_ex(("localhost", port)) != 0

haplohub_cli/core/slug.py

@@ -0,0 +1,7 @@
+import re
+
+non_alphanum_re = re.compile(r"[^a-z0-9]+")
+
+
+def slugify(text: str) -> str:
+    return non_alphanum_re.sub("-", text.lower()).strip("-")

haplohub_cli/core/tests/test_network.py

@@ -0,0 +1,20 @@
+import socket
+from unittest import TestCase
+
+from haplohub_cli.core.network import check_port_available
+
+
+class NetworkTestCase(TestCase):
+    def test_check_port_available_should_return_true_when_port_is_available(self):
+        with socket.socket() as sock:
+            sock.bind(("localhost", 0))
+            port = sock.getsockname()[1]
+
+        self.assertTrue(check_port_available(port))
+
+    def test_check_port_available_should_return_false_when_port_is_not_available(self):
+        with socket.socket() as sock:
+            sock.bind(("localhost", 0))
+            port = sock.getsockname()[1]
+            sock.listen()
+            self.assertFalse(check_port_available(port))

haplohub_cli/core/tests/test_slug.py

@@ -0,0 +1,20 @@
+from unittest import TestCase
+
+from haplohub_cli.core.slug import slugify
+
+
+class SlugifyTestCase(TestCase):
+    def test_slugify_should_return_lowercase_string(self):
+        self.assertEqual(slugify("Hello World"), "hello-world")
+
+    def test_slugify_should_replace_spaces_with_hyphens(self):
+        self.assertEqual(slugify("Hello World"), "hello-world")
+
+    def test_slugify_should_remove_special_characters(self):
+        self.assertEqual(slugify("Hello World!"), "hello-world")
+
+    def test_slugify_should_remove_extra_spaces(self):
+        self.assertEqual(slugify("Hello   World"), "hello-world")
+
+    def test_slugify_should_keep_unchanged_when_no_changes_are_needed(self):
+        self.assertEqual(slugify("hello-world"), "hello-world")

haplohub_cli/formatters/__init__.py

@@ -0,0 +1,6 @@
+# flake8: noqa
+from .cohort import *
+from .config import *
+from .file import *
+from .generic import *
+from .model import *

haplohub_cli/formatters/cohort.py

@@ -0,0 +1,39 @@
+from haplohub import (
+    CohortSchema,
+    CreateCohortResponse,
+    PaginatedResponseCohortSchema,
+)
+from rich.table import Table
+
+from haplohub_cli.formatters import utils
+from haplohub_cli.formatters.decorators import register
+
+
+@register(CohortSchema)
+def format_cohort(data: CohortSchema):
+    table = Table(title="Cohort", caption=f"Id: {data.id}")
+    table.add_column("Id")
+    table.add_column("Name")
+    table.add_column("Description")
+    table.add_column("Created")
+    table.add_row(str(data.id), data.name, data.description, utils.format_date(data.created))
+    return table
+
+
+@register(PaginatedResponseCohortSchema)
+def format_cohorts(data: PaginatedResponseCohortSchema):
+    table = Table(title="Cohorts", caption=f"Total: {data.total_count}")
+    table.add_column("Id")
+    table.add_column("Name")
+    table.add_column("Description")
+    table.add_column("Created")
+
+    for item in data.items:
+        table.add_row(str(item.id), item.name, utils.truncate(item.description, 50), utils.format_date(item.created))
+
+    return table
+
+
+@register(CreateCohortResponse)
+def format_create_cohort(data: CreateCohortResponse):
+    return format_cohort(data.result)

haplohub_cli/formatters/config.py

@@ -0,0 +1,15 @@
+from rich.table import Table
+
+from haplohub_cli.config.config import Config
+from haplohub_cli.formatters.decorators import register
+
+
+@register(Config)
+def format_config(data: Config):
+    table = Table(title="Config")
+    table.add_column("Key")
+    table.add_column("Value")
+
+    for key, value in data.dict().items():
+        table.add_row(key, str(value))
+    return table

haplohub_cli/formatters/decorators.py

@@ -0,0 +1,9 @@
+from haplohub_cli.formatters.formatter_registry import formatter_registry
+
+
+def register(model_type):
+    def decorator(func):
+        formatter_registry.register_formatter(model_type, func)
+        return func
+
+    return decorator

haplohub_cli/formatters/file.py

@@ -0,0 +1,46 @@
+from haplohub import (
+    FileSchema,
+    ResultResponseFileDirSchema,
+    ResultResponseFileSchema,
+)
+from rich.table import Table
+
+from haplohub_cli.formatters import utils
+from haplohub_cli.formatters.decorators import register
+
+
+@register(FileSchema)
+def format_file(data: FileSchema):
+    table = Table(title="File", caption=f"Id: {data.id}")
+    table.add_column("Id")
+    table.add_column("File name")
+    table.add_column("Size")
+    table.add_column("Created")
+    table.add_row(str(data.id), data.location, str(data.file_size), utils.format_date(data.created))
+    return table
+
+
+@register(ResultResponseFileDirSchema)
+def format_files(data: ResultResponseFileDirSchema):
+    result = data.result
+    table = Table(
+        title=f"Contents of {result.location or 'ROOT'}",
+        caption=f"Total files: {len(result.files)}, total dirs: {len(result.dirs)}",
+    )
+    table.add_column("Id")
+    table.add_column("File name")
+    table.add_column("Size")
+    table.add_column("Created")
+
+    for dir in result.dirs:
+        table.add_row("DIR", dir.location + "/")
+
+    for file in result.files:
+        table.add_row(str(file.id), file.location, str(file.file_size), utils.format_date(file.created))
+
+    return table
+
+
+@register(ResultResponseFileSchema)
+def format_result_response_file(data: ResultResponseFileSchema):
+    return format_file(data.result)

haplohub_cli/formatters/formatter_registry.py

@@ -0,0 +1,21 @@
+from rich.console import Console
+
+
+class FormatterRegistry:
+    def __init__(self):
+        self.formatters = {}
+        self.console = Console()
+
+    def register_formatter(self, model_type, formatter):
+        self.formatters[model_type] = formatter
+
+    def has_formatter(self, model_type):
+        return model_type in self.formatters
+
+    def format(self, model):
+        formatter = self.formatters[type(model)]
+        output = formatter(model)
+        self.console.print(output)
+
+
+formatter_registry = FormatterRegistry()

haplohub_cli/formatters/generic.py

@@ -0,0 +1,11 @@
+from haplohub import (
+    ErrorResponse,
+)
+from rich.text import Text
+
+from haplohub_cli.formatters.decorators import register
+
+
+@register(ErrorResponse)
+def format_error_response(data: ErrorResponse):
+    return Text(f"Error [{data.error.code}]: {data.error.message}", style="red")

haplohub_cli/formatters/model.py

@@ -0,0 +1,31 @@
+from haplohub import (
+    MLModelSchema,
+    PaginatedResponseMLModelSchema,
+)
+from rich.table import Table
+
+from haplohub_cli.formatters import utils
+from haplohub_cli.formatters.decorators import register
+
+
+@register(MLModelSchema)
+def format_model(data: MLModelSchema):
+    table = Table(title="Model", caption=f"Id: {data.id}")
+    table.add_column("Id")
+    table.add_column("Name")
+    table.add_column("Created")
+    table.add_row(str(data.id), data.name, utils.format_date(data.created))
+    return table
+
+
+@register(PaginatedResponseMLModelSchema)
+def format_models(data: PaginatedResponseMLModelSchema):
+    table = Table(title="Models", caption=f"Total: {data.total_count}")
+    table.add_column("Id")
+    table.add_column("Name")
+    table.add_column("Created")
+
+    for item in data.items:
+        table.add_row(str(item.id), item.name, utils.format_date(item.created))
+
+    return table

haplohub_cli/formatters/utils.py

@@ -0,0 +1,13 @@
+from datetime import datetime
+
+import pendulum
+
+
+def format_date(date: datetime) -> str:
+    return pendulum.instance(date).to_day_datetime_string()
+
+
+def truncate(text: str, length: int) -> str:
+    if len(text) <= length:
+        return text
+    return text[:length] + "..."

haplohub_cli/settings.py

@@ -0,0 +1,24 @@
+from os import environ
+from posixpath import expanduser, join
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# File paths
+CONFIG_DIR = expanduser("~/.haplohub")
+CONFIG_FILE = join(CONFIG_DIR, "config.json")
+CREDENTIALS_FILE = join(CONFIG_DIR, "credentials.json")
+
+# Authentication
+REDIRECT_PORT = 8088
+
+AUTH0_REDIRECT_URI = f"http://localhost:{REDIRECT_PORT}/"
+AUTH0_DOMAIN = environ.get("AUTH0_DOMAIN", "dev-42a7qv136prmsazj.us.auth0.com")
+AUTH0_CLIENT_ID = environ.get("AUTH0_CLIENT_ID", "TRi894X7yV3e8EOpNVrDdvQbRvYnjibH")
+AUTH0_AUDIENCE = environ.get("AUTH0_AUDIENCE", "https://haplohub.com/api/")
+
+# API
+API_URL = environ.get("API_URL", "http://localhost:8000")
+
+environ["DOCKER_CONFIG"] = join(CONFIG_DIR, "docker")

haplohub_cli-0.0.1.dist-info/METADATA

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: haplohub-cli
+Version: 0.0.1
+Summary: HaploHub Command Line Interface
+Author-email: Mike Polcari <mike@haplotype-labs.com>, Ilya Khrustalev <ilya@haplotype-labs.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: auth0-python>=4.8.0
+Requires-Dist: click>=8.1.8
+Requires-Dist: haplohub>=1.0.4
+Requires-Dist: pendulum>=3.0.0
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: requests>=2.32.0
+Requires-Dist: rich>=13.9.4
+Requires-Dist: haplohub
+
+# HaploHub CLI
+
+HaploHub is a platform for haplotype data storage and analysis. This CLI provides a way to interact with the HaploHub API.
+
+## Installation
+
+To install the CLI, run the following command:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install --upgrade pip
+pip install haplohub-cli
+```
+
+You can ensure that the CLI is installed correctly by running the following command:
+
+```bash
+haplohub version
+
+# HaploHub CLI version 0.1.0
+```
+
+## Usage
+
+```bash
+haplohub --help
+```
+
+### Login
+
+The first time you run the CLI, you will be prompted to login.
+
+```bash
+haplohub login
+```
+
+This will open a browser window to the HaploHub login page. Once you login, you will be redirected to the CLI.
+```bash
+Your browser has been opened to authenticate with HaploHub.
+
+    https://xxx.us.auth0.com/authorize...
+
+Successfully authenticated with HaploHub.
+```

haplohub_cli-0.0.1.dist-info/RECORD

@@ -0,0 +1,48 @@
+haplohub_cli/__init__.py,sha256=v-rRiDOgZ3sQSMQKq0vgUQZvpeOkoHFXissAx6Ktg84,61
+haplohub_cli/_version.py,sha256=vgltXBYF55vNcC2regxjGN0_cbebmm8VgcDdQaDapWQ,511
+haplohub_cli/cli.py,sha256=dAzULnl-tNtJn2LAzfEU57SixYGHClgMpZm5qkoEeDE,782
+haplohub_cli/settings.py,sha256=oticVH4RzBrIVYUbtXLbHMwHUFutqYecQVI4EY-64Is,723
+haplohub_cli/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haplohub_cli/auth/auth.py,sha256=GXs2vHpAsBh7aIJJDzNs-cj6Jr_wJx5md8cWhOghKlg,1530
+haplohub_cli/auth/auth0_client.py,sha256=c5jseQTm5trUtyfV4fF81einREb8ni4I8xY2SNJDn64,3457
+haplohub_cli/auth/auth_web_server.py,sha256=QXgCSqmVrqfLcXuaRSjWDzXEogtY5Zs3_2nxINZ_xn8,1115
+haplohub_cli/auth/token_storage.py,sha256=PUD3bjOvcUQQfC6tbrLQd4tQ-5eKcxxc8LvxueeGe3Y,657
+haplohub_cli/auth/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haplohub_cli/auth/tests/test_auth_web_server.py,sha256=YBJe78CCXN25TPmKY0zFNsXi2ZG7awREy90kS3VWtag,667
+haplohub_cli/auth/tests/test_token_storage.py,sha256=MOy6M1ukCZIHPLDvTPHtqvSscnQQkIttmAdLYFg2r1A,1368
+haplohub_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haplohub_cli/commands/cohort.py,sha256=jjo4nsonREwVRdcRPixQemMmkLoGLtGaZJ1LC7ccJ7Y,643
+haplohub_cli/commands/config.py,sha256=lVzRbSLgEwxL5OEUp4lr8ceQSz2CIbXph5Hjh5C2_fo,794
+haplohub_cli/commands/file.py,sha256=OI3Y9sgRi-12J2Puba7e13ObabsmF1ozO4nb22ItEZ4,2781
+haplohub_cli/commands/login.py,sha256=Mq_Sc5WhXBiL5DaiqGsCT9obJ3FM4v6AjbWv6UOmpwI,352
+haplohub_cli/commands/version.py,sha256=KivIR_PbALJSQnPyDM03DGac6oKevv9gYvykDVddJ4A,205
+haplohub_cli/commands/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haplohub_cli/commands/model/model.py,sha256=210wv0VWTqChyaUs57JYwv3cAOISISY05JVrH6X-CvY,1610
+haplohub_cli/commands/model/run.py,sha256=kyGGrvXx9LJDuJTt7pTNdZqj1W21P0oAvqhlBBglOe0,1300
+haplohub_cli/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haplohub_cli/config/config.py,sha256=ihtV98nX89qUeG6LRrRh5tA2132P-TwIwlH4wMgD13c,275
+haplohub_cli/config/config_manager.py,sha256=y0XH01La3B4nZnnOeiVU7Rb9GXRvkJfJdsjrsM6C9qk,1354
+haplohub_cli/config/environments.py,sha256=ftOyp5EB6ioRX5eUsTiECYm_E93GmYmFBjWF1Q8J9x0,764
+haplohub_cli/core/__init__.py,sha256=yXeki15WeA3_2s1OvMtZ_medNHZsfXQPDVUZ2UK20Uc,124
+haplohub_cli/core/checksum.py,sha256=7bA6UTX9RuYC0wSTKyfjD2wCLUJMrkeDBmTFH9DdL9w,183
+haplohub_cli/core/network.py,sha256=EfHkeG3FiT3zfzTS9vfUJMT2HauOa6wlUOVVxAQ_kgU,172
+haplohub_cli/core/slug.py,sha256=wXzXrQa9F1dDWE3HzXklVicTZWXBNfaG1Qtdm-ZYo0k,149
+haplohub_cli/core/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haplohub_cli/core/api/client.py,sha256=d_xhz3rgldGf0R-3V5T4HZWGWct351hZlaGHCwNkPr0,958
+haplohub_cli/core/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haplohub_cli/core/tests/test_network.py,sha256=mqWChARUmhi4s2_mmh-n29huay1tjI6eG7OTkBTRz5g,685
+haplohub_cli/core/tests/test_slug.py,sha256=vufw7ppXY8exalwTcYbfhSHPceFrnLwF7uGlcA9nwvI,751
+haplohub_cli/formatters/__init__.py,sha256=dG5qxS0NnjKsm2zud2KROYRSvnMBPVqJt_zIEu-e8uI,123
+haplohub_cli/formatters/cohort.py,sha256=HSBIknvDLOTOZXSiJn_fQoC52znRCnIzHpkvCrfl2LE,1180
+haplohub_cli/formatters/config.py,sha256=A4CRpsuVx6n5E4CROkGS8jq-mmA7VXBVLN6sI1agIXY,377
+haplohub_cli/formatters/decorators.py,sha256=FQ-l8wt6nfsYxRWE-rMLN_aDyEiCk8zr6WpnkJVCpek,233
+haplohub_cli/formatters/file.py,sha256=yTcMQONhDvl2eMzpw__siy3IRhnheqagFbZxezEUKr4,1369
+haplohub_cli/formatters/formatter_registry.py,sha256=InKpKGJQs46QW4bdVTdRs25k92ufD8pHdK4nxa6JHK4,530
+haplohub_cli/formatters/generic.py,sha256=-kELlDLyzDQOYnrQAXVmFr00JPbBmucxRqZsYzHIU_A,284
+haplohub_cli/formatters/model.py,sha256=COyjwTnI46ZHVKk9KlzdooUj4KbcW4r6tj6qa86eJd0,902
+haplohub_cli/formatters/utils.py,sha256=DKGHRWkfcCE83RX2ftVJ5h_lTPgV4fb-bdcowapopdw,277
+haplohub_cli-0.0.1.dist-info/METADATA,sha256=YgbP86smkVB6YylC-u-QhzgI_uXU8PhzTx0EosnCZIw,1375
+haplohub_cli-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+haplohub_cli-0.0.1.dist-info/entry_points.txt,sha256=dXlR_dnajZR8kZtq_a7nhsQE2--qoogM0InAfLJPn74,50
+haplohub_cli-0.0.1.dist-info/top_level.txt,sha256=aGE0jcVMW4ia9SkOxCcv44UP0jhEQp_tOYScfUtbesU,13
+haplohub_cli-0.0.1.dist-info/RECORD,,

haplohub_cli-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

haplohub_cli-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+haplohub = haplohub_cli.cli:cli

haplohub_cli-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+haplohub_cli