cli config

Author: snopoke

poetry.lock

@@ -17,6 +17,7 @@ httpx = ">=0.15.4,<0.24.0"
 attrs = ">=21.3.0"
 python-dateutil = "^2.8.0"
 typer = {extras = ["all"], version = "^0.7.0"}
+tomlkit = "^0.11.6"
 
 [tool.poetry.group.dev.dependencies]
 openapi-python-client = "^0.13.1"

pyproject.toml

@@ -1,2 +1,2 @@
 from .integrations import Action, EmailIntegration
-from .sdk import Task, init, init_from_env, update_task
+from .sdk import Task, init, update_task

taskbadger/__init__.py

@@ -1,24 +1,71 @@
 import subprocess
-from typing import List
+from typing import Optional
 
 import typer
+from rich import print
 
 import taskbadger as tb
+from taskbadger.config import get_config, write_config
+from taskbadger.exceptions import ConfigurationError
 
 app = typer.Typer()
 
-tb.init_from_env()
 
+def _configure_api(ctx):
+    config = ctx.meta["tb_config"]
+    try:
+        config.init_api()
+    except ConfigurationError as e:
+        print(f"[red]{str(e)}[/red]")
+        raise typer.Exit(code=1)
 
-@app.command()
-def monitor(name: str, command: List[str] = typer.Argument(None)):
+
+@app.command(context_settings={"allow_extra_args": True, "ignore_unknown_options": True})
+def monitor(ctx: typer.Context, name: str):
+    _configure_api(ctx)
     task = tb.Task.create(name)
-    result = subprocess.run(command, env={"TASKBADGER_TASK_ID": task.id})
+    result = subprocess.run(ctx.args, env={"TASKBADGER_TASK_ID": task.id})
     if result.returncode != 0:
         task.success()
     else:
         task.error(data={"return_code": result.returncode})
 
 
+@app.command()
+def configure(ctx: typer.Context):
+    config = ctx.meta["tb_config"]
+    config.token = typer.prompt(f"Token", default=config.token)
+    config.organization_slug = typer.prompt(f"Organization slug", default=config.organization_slug)
+    config.project_slug = typer.prompt(f"Project slug", default=config.project_slug)
+    path = write_config(config)
+    print(f"Config written to [green]{path}[/green]")
+
+
+@app.command()
+def docs():
+    typer.launch("https://docs.taskbadger.net")
+
+
+@app.command()
+def info(ctx: typer.Context):
+    config = ctx.meta["tb_config"]
+    print(f"Default Organization: {config.organization_slug or '-'}")
+    print(f"Default Project: {config.project_slug or '-'}")
+    print(f"Auth Token: {config.token or '-'}")
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    org: Optional[str] = typer.Option(None, "--org", "-o", metavar="ORG"),
+    project: Optional[str] = typer.Option(None, "--project", "-p", show_envvar=False, metavar="PROJECT"),
+):
+    """
+    Manage users in the awesome CLI app.
+    """
+    config = get_config(org=org, project=project)
+    ctx.meta["tb_config"] = config
+
+
 if __name__ == "__main__":
     app()

taskbadger/cli.py

@@ -0,0 +1,71 @@
+import dataclasses
+import os
+from pathlib import Path
+
+import tomlkit
+import typer
+from tomlkit import document, table
+
+import taskbadger as tb
+
+APP_NAME = "taskbadger"
+
+
+@dataclasses.dataclass
+class Config:
+    token: str = None
+    organization_slug: str = None
+    project_slug: str = None
+
+    def is_valid(self):
+        return bool(self.token and self.organization_slug and self.project_slug)
+
+    def init_api(self):
+        tb.init(self.organization_slug, self.project_slug, self.token)
+
+    @staticmethod
+    def from_dict(config_dict, **overrides) -> "Config":
+        defaults = config_dict.get("defaults", {})
+        auth = config_dict.get("auth", {})
+        return Config(
+            token=overrides.get("token") or _from_env("TOKEN", auth.get("token")),
+            organization_slug=overrides.get("org") or _from_env("ORG", defaults.get("org")),
+            project_slug=overrides.get("project") or _from_env("PROJECT", defaults.get("project")),
+        )
+
+
+def _from_env(name, default=None, prefix="TASKBADGER_"):
+    return os.environ.get(f"{prefix}{name}", default)
+
+
+def write_config(config):
+    doc = document()
+
+    doc.add("defaults", table().add("org", config.organization_slug).add("project", config.project_slug))
+
+    doc.add("auth", table().add("token", config.token))
+
+    config_path = _get_config_path()
+    if not config_path.parent.exists():
+        config_path.parent.mkdir(parents=True)
+    with config_path.open("wt", encoding="utf-8") as fp:
+        tomlkit.dump(doc, fp)
+
+    return config_path
+
+
+def get_config(**overrides):
+    config_dict = {}
+    config_path = _get_config_path()
+    if config_path.is_file():
+        with config_path.open("rt", encoding="utf-8") as fp:
+            raw_config = tomlkit.load(fp)
+        config_dict = raw_config.unwrap()
+
+    return Config.from_dict(config_dict, **overrides)
+
+
+def _get_config_path():
+    app_dir = typer.get_app_dir(APP_NAME)
+    config_path: Path = Path(app_dir) / "config"
+    return config_path

taskbadger/config.py

@@ -0,0 +1,6 @@
+class ConfigurationError(Exception):
+    def __init__(self, **kwargs):
+        self.missing = [name for name, arg in kwargs.items() if arg is None]
+
+    def __str__(self):
+        return f"Missing configuration parameters: {', '.join(self.missing)}"

taskbadger/exceptions.py

@@ -5,6 +5,7 @@
 from _contextvars import ContextVar
 
 from taskbadger import Action
+from taskbadger.exceptions import ConfigurationError
 from taskbadger.internal import AuthenticatedClient, errors
 from taskbadger.internal.api.task_endpoints import task_create, task_get, task_partial_update
 from taskbadger.internal.models import PatchedTaskRequest, PatchedTaskRequestData, StatusEnum
@@ -15,23 +16,27 @@
 _local = ContextVar("taskbadger_client")
 
 
-def init_from_env():
-    _init(
-        os.environ["TASKBADGER_ORG"],
-        os.environ["TASKBADGER_PROJECT"],
-        os.environ["TASKBADGER_TOKEN"],
-    )
-
-
-def init(organization_slug: str, project_slug: str, token: str):
+def init(organization_slug: str = None, project_slug: str = None, token: str = None):
     _init("https://taskbadger.net", organization_slug, project_slug, token)
 
 
-def _init(host: str, organization_slug: str, project_slug: str, token: str):
-    client = AuthenticatedClient(host, token)
-    settings = Settings(client, organization_slug, project_slug)
+def _init(host: str = None, organization_slug: str = None, project_slug: str = None, token: str = None):
+    host = host or os.environ.get("TASKBADGER_HOST", "https://taskbadger.net")
+    organization_slug = organization_slug or os.environ.get("TASKBADGER_ORG")
+    project_slug = project_slug or os.environ.get("TASKBADGER_PROJECT")
+    token = token or os.environ.get("TASKBADGER_TOKEN")
 
-    _local.set(settings)
+    if host and organization_slug and project_slug and token:
+        client = AuthenticatedClient(host, token)
+        settings = Settings(client, organization_slug, project_slug)
+        _local.set(settings)
+    else:
+        raise ConfigurationError(
+            host=host,
+            organization_slug=organization_slug,
+            project_slug=project_slug,
+            token=token,
+        )
 
 
 def get_task(task_id: str):