haplohub-cli 0.0.1__tar.gz

haplohub_cli-0.0.1/.env.sample

@@ -0,0 +1,3 @@
+AUTH0_DOMAIN='xxx-yyy.us.auth0.com'
+AUTH0_CLIENT_ID='xxx'
+AUTH0_AUDIENCE='https://xxx/api/'

haplohub_cli-0.0.1/.github/workflows/on_pr.yml

@@ -0,0 +1,27 @@
+name: On Pull Request
+
+on:
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: uv sync --dev
+      - name: Lint and format with ruff
+        run: |
+          ruff format --check .
+          ruff check .
+      - name: Run tests
+        run: uv run pytest -v

haplohub_cli-0.0.1/.github/workflows/on_push_main.yml

@@ -0,0 +1,79 @@
+name: On Push to Main
+
+on:
+  push:
+    branches: [main]
+    tags: ["v[0-9]+.[0-9]+.[0-9]+*"]
+
+permissions:
+  attestations: write
+  contents: write
+  id-token: write
+
+jobs:
+  build:
+    name: Build python package
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: hynek/build-and-inspect-python-package@v2
+        with:
+          attest-build-provenance-github: 'true'
+
+  publish-test-pypi:
+    name: Publish to Test PyPI
+    runs-on: ubuntu-latest
+    needs: build
+    environment: testpypi
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: Packages
+          path: dist
+      - name: Publish to Test PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          verbose: true
+          repository-url: https://test.pypi.org/legacy/
+
+  publish-pypi:
+    name: Publish to PyPI
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/v')
+    needs: build
+    environment: pypi
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: Packages
+          path: dist
+      - name: Publish to Test PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          verbose: true
+
+  github-release:
+    name: Create GitHub Release
+    runs-on: ubuntu-latest
+    needs: publish-pypi
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: Packages
+          path: dist
+      - name: Sign the dists with Sigstore
+        uses: sigstore/gh-action-sigstore-python@v3.0.0
+        with:
+          inputs: >-
+            ./dist/*.tar.gz
+            ./dist/*.whl
+      - name: Create GitHub Release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ github.ref }}
+          release_name: Release ${{ github.ref }}
+          body: Release ${{ github.ref }}

haplohub_cli-0.0.1/.gitignore

@@ -0,0 +1,18 @@
+# Environment variables
+.env
+
+# Virtual environment
+.venv/
+
+# Python caches, tools caches
+__pycache__/
+.ruff_cache/
+.pytest_cache/
+
+# Distribution files
+dist/
+*.egg-info/
+haplohub_cli/_version.py
+
+# Mac OS
+.DS_Store

haplohub_cli-0.0.1/.pre-commit-config.yaml

@@ -0,0 +1,19 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.9.6
+    hooks:
+      - id: ruff
+        args: ["--fix"]
+        always_run: true
+      - id: ruff-format
+        always_run: true
+  - repo: local
+    hooks:
+      - id: tests
+        stages: [push]
+        name: Run tests
+        entry: uv run pytest -v
+        language: system
+        verbose: true
+        pass_filenames: false
+        always_run: true

haplohub_cli-0.0.1/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,45 @@
+# 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/haplohub_cli/__init__.py

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

haplohub_cli-0.0.1/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-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-0.0.1/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-0.0.1/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-0.0.1/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-0.0.1/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-0.0.1/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-0.0.1/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-0.0.1/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-0.0.1/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