taskbadger 0.4.4__tar.gz → 0.8.0__tar.gz

{taskbadger-0.4.4 → taskbadger-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: taskbadger
-Version: 0.4.4
+Version: 0.8.0
 Summary: The official Python SDK for Task Badger
 Home-page: https://taskbadger.net/
 License: Apache-2.0
@@ -19,13 +19,15 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.6
 Classifier: Programming Language :: Python :: 3.7
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Provides-Extra: celery
 Requires-Dist: attrs (>=21.3.0)
-Requires-Dist: httpx (>=0.15.4,<0.24.0)
+Requires-Dist: celery (>=4.0.0,<6.0.0) ; extra == "celery"
+Requires-Dist: httpx (>=0.20.0,<0.25.0)
 Requires-Dist: importlib-metadata (>=1.0,<2.0) ; python_version < "3.8"
 Requires-Dist: python-dateutil (>=2.8.0,<3.0.0)
 Requires-Dist: tomlkit (>=0.11.6,<0.12.0)
-Requires-Dist: typer[all] (>=0.7.0,<0.8.0)
-Requires-Dist: typing-extensions (>=4.6.1,<5.0.0) ; python_version == "3.9"
+Requires-Dist: typer[all] (>=0.9.0,<0.10.0)
+Requires-Dist: typing-extensions (>=4.7.1,<5.0.0) ; python_version == "3.9"
 Project-URL: Documentation, https://docs.taskbadger.net/
 Project-URL: Repository, https://github.com/taskbadger/taskbadger-docs
 Description-Content-Type: text/markdown
@@ -63,7 +65,7 @@ taskbadger.init(
 #### API Example
 
 ```python
-from taskbadger import Task, Action, EmailIntegration
+from taskbadger import Task, Action, EmailIntegration, WebhookIntegration
 
 # create a new task with custom data and an action definition
 task = Task.create(
@@ -72,10 +74,8 @@ task = Task.create(
         "custom": "data"
     },
     actions=[
-        Action(
-            "*/10%,success,error",
-            integration=EmailIntegration(to="me@example.com")
-        )
+        Action("*/10%,success,error", integration=EmailIntegration(to="me@example.com")),
+        Action("cancelled", integration=WebhookIntegration(id="webhook:demo")),
     ]
 )
 
@@ -117,7 +117,7 @@ Config written to ~/.config/taskbadger/config
 The CLI `run` command executes your command whilst creating and updating a Task Badger task.
 
 ```shell
-$ taskbadger run "demo task" --action "error email to:me@test.com" -- path/to/script.sh
+$ taskbadger run "demo task" --action error email to:me@test.com -- path/to/script.sh
 
 Task created: https://taskbadger.net/public/tasks/xyz/
 ```

{taskbadger-0.4.4 → taskbadger-0.8.0}/README.md

@@ -31,7 +31,7 @@ taskbadger.init(
 #### API Example
 
 ```python
-from taskbadger import Task, Action, EmailIntegration
+from taskbadger import Task, Action, EmailIntegration, WebhookIntegration
 
 # create a new task with custom data and an action definition
 task = Task.create(
@@ -40,10 +40,8 @@ task = Task.create(
         "custom": "data"
     },
     actions=[
-        Action(
-            "*/10%,success,error",
-            integration=EmailIntegration(to="me@example.com")
-        )
+        Action("*/10%,success,error", integration=EmailIntegration(to="me@example.com")),
+        Action("cancelled", integration=WebhookIntegration(id="webhook:demo")),
     ]
 )
 
@@ -85,7 +83,7 @@ Config written to ~/.config/taskbadger/config
 The CLI `run` command executes your command whilst creating and updating a Task Badger task.
 
 ```shell
-$ taskbadger run "demo task" --action "error email to:me@test.com" -- path/to/script.sh
+$ taskbadger run "demo task" --action error email to:me@test.com -- path/to/script.sh
 
 Task created: https://taskbadger.net/public/tasks/xyz/
 ```

{taskbadger-0.4.4 → taskbadger-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "taskbadger"
-version = "0.4.4"
+version = "0.8.0"
 description = "The official Python SDK for Task Badger"
 license = "Apache-2.0"
 
@@ -32,25 +32,30 @@ classifiers = [
 
 [tool.poetry.dependencies]
 python = "^3.8"
-httpx = ">=0.15.4,<0.24.0"
+httpx = ">=0.20.0,<0.25.0"
 attrs = ">=21.3.0"
 python-dateutil = "^2.8.0"
-typer = {extras = ["all"], version = "^0.7.0"}
+typer = {extras = ["all"], version = "^0.9.0"}
 tomlkit = "^0.11.6"
 importlib-metadata = {version = "^1.0", python = "<3.8"}
-typing-extensions = {version = "^4.6.1", python = "3.9"}
+typing-extensions = {version = "^4.7.1", python = "3.9"}
+celery = {version = ">=4.0.0,<6.0.0", optional = true}
+
+[tool.poetry.extras]
+celery = ["celery"]
 
 [tool.poetry.group.dev.dependencies]
-openapi-python-client = "^0.13.1"
+openapi-python-client = "^0.15.1"
 pytest = "^7.2.1"
 isort = "^5.12.0"
 black = "^23.1.0"
 pre-commit = "^3.0.2"
 pytest-httpx = "^0.21.3"
 invoke = "^2.0.0"
+pytest-celery = "^0.0.0"
 
 [tool.poetry.scripts]
-taskbadger = "taskbadger.cli:app"
+taskbadger = "taskbadger.cli_main:app"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]

{taskbadger-0.4.4 → taskbadger-0.8.0}/taskbadger/__init__.py

@@ -1,7 +1,8 @@
-from .integrations import Action, EmailIntegration
+from .integrations import Action, EmailIntegration, WebhookIntegration
 from .internal.models import StatusEnum
+from .mug import Session
 from .safe_sdk import create_task_safe, update_task_safe
-from .sdk import Task, create_task, get_task, init, update_task
+from .sdk import DefaultMergeStrategy, Task, create_task, get_task, init, update_task
 
 try:
     import importlib.metadata as importlib_metadata

taskbadger-0.8.0/taskbadger/cli/__init__.py

@@ -0,0 +1,3 @@
+from .basics import create, get, update
+from .list_tasks import list_tasks_command
+from .wrapper import run

taskbadger-0.8.0/taskbadger/cli/basics.py

@@ -0,0 +1,126 @@
+import csv
+import json
+import sys
+from typing import Tuple
+
+import typer
+from rich import print
+
+from taskbadger import StatusEnum, create_task, get_task, update_task
+from taskbadger.cli.utils import OutputFormat, configure_api, err_console, get_actions, get_metadata
+
+
+def get(
+    ctx: typer.Context,
+    task_id: str = typer.Argument(..., show_default=False, help="The ID of the task."),
+    output_format: OutputFormat = typer.Option(OutputFormat.pretty, "--format", "-f", help="Output format"),
+):
+    """Get a task."""
+    configure_api(ctx)
+    task = get_task(task_id)
+    if output_format == OutputFormat.pretty:
+        print(f"Task ID: {task.id}")
+        print(f"Created: {task.created.isoformat()}")
+        print(f"Name: {task.name}")
+        print(f"Status: {task.status}")
+        print(f"Percent: {task.value_percent}%")
+    elif output_format == OutputFormat.json:
+        print(json.dumps(task.to_dict(), indent=2))
+    elif output_format == OutputFormat.csv:
+        writer = csv.writer(sys.stdout)
+        writer.writerow("Task ID,Created,Name,Status,Percent".split(","))
+        writer.writerow([task.id, task.created.isoformat(), task.name, task.status, str(task.value_percent)])
+
+
+def create(
+    ctx: typer.Context,
+    name: str = typer.Argument(..., show_default=False, help="The task name."),
+    monitor_id: str = typer.Option(None, help="Associate this task with a monitor."),
+    action_def: Tuple[str, str, str] = typer.Option(
+        (None, None, None),
+        "--action",
+        "-a",
+        metavar="<trigger integration config>",
+        show_default=False,
+        help="Action definition e.g. 'success,error email to:me@email.com'",
+    ),
+    status: StatusEnum = typer.Option(StatusEnum.PROCESSING, help="The initial status of the task."),
+    value_max: int = typer.Option(100, help="The maximum value for the task."),
+    metadata: list[str] = typer.Option(
+        None,
+        show_default=False,
+        help="Metadata 'key=value' pair to associate with the task. Can be specified multiple times.",
+    ),
+    metadata_json: str = typer.Option(
+        None, show_default=False, help="Metadata to associate with the task. Must be valid JSON."
+    ),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Minimal output. Only the Task ID."),
+):
+    """Create a task."""
+    configure_api(ctx)
+    actions = get_actions(action_def)
+    metadata = get_metadata(metadata, metadata_json)
+
+    try:
+        task = create_task(
+            name,
+            status=status,
+            value_max=value_max,
+            data=metadata,
+            actions=actions,
+            monitor_id=monitor_id,
+        )
+    except Exception as e:
+        err_console.print(f"Error creating task: {e}")
+    else:
+        if quiet:
+            print(task.id)
+        else:
+            print(f"Task created: {task.public_url}")
+
+
+def update(
+    ctx: typer.Context,
+    task_id: str = typer.Argument(..., show_default=False, help="The ID of the task to update."),
+    name: str = typer.Option(None, show_default=False, help="Update the name of the task."),
+    action_def: Tuple[str, str, str] = typer.Option(
+        (None, None, None),
+        "--action",
+        "-a",
+        metavar="<trigger integration config>",
+        show_default=False,
+        help="Action definition e.g. 'success,error email to:me@email.com'",
+    ),
+    status: StatusEnum = typer.Option(StatusEnum.PROCESSING, help="The status of the task."),
+    value: int = typer.Option(None, show_default=False, help="The current task value (progress)."),
+    value_max: int = typer.Option(None, show_default=False, help="The maximum value for the task."),
+    metadata: list[str] = typer.Option(
+        None,
+        show_default=False,
+        help="Metadata 'key=value' pair to associate with the task. Can be specified multiple times.",
+    ),
+    metadata_json: str = typer.Option(
+        None, show_default=False, help="Metadata to associate with the task. Must be valid JSON."
+    ),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="No output."),
+):
+    """Update a task."""
+    configure_api(ctx)
+    actions = get_actions(action_def)
+    metadata = get_metadata(metadata, metadata_json)
+
+    try:
+        task = update_task(
+            task_id,
+            name=name,
+            status=status,
+            value=value,
+            value_max=value_max,
+            data=metadata,
+            actions=actions,
+        )
+    except Exception as e:
+        err_console.print(f"Error creating task: {e}")
+    else:
+        if not quiet:
+            print(f"Task updated: {task.public_url}")

taskbadger-0.8.0/taskbadger/cli/list_tasks.py

@@ -0,0 +1,79 @@
+import csv
+import json
+import sys
+from urllib.parse import parse_qs, urlparse
+
+import typer
+from rich import print
+from rich.console import Console
+from rich.table import Table
+
+from taskbadger.cli.utils import OutputFormat, configure_api
+from taskbadger.sdk import list_tasks
+
+
+def list_tasks_command(
+    ctx: typer.Context,
+    output_format: OutputFormat = typer.Option(OutputFormat.pretty, "--format", "-f", help="Output format"),
+    limit: int = typer.Option(100, help="Limit the number of results."),
+    start_token: str = typer.Option(None, show_default=False, help="Start token."),
+):
+    """List tasks."""
+    configure_api(ctx)
+    tasks = list_tasks(page_size=limit, cursor=start_token)
+    render(output_format, ctx, tasks)
+
+
+def render(format_: OutputFormat, ctx, result):
+    if format_ == OutputFormat.pretty:
+        _render_pretty(ctx, result)
+    elif format_ == OutputFormat.json:
+        _render_json(ctx, result)
+    elif format_ == OutputFormat.csv:
+        _render_csv(ctx, result)
+    else:
+        raise ValueError(f"Unknown format: {format_}")
+
+
+def _render_pretty(ctx, result):
+    table = Table(
+        title=f"Project: {ctx.meta['tb_config'].project_slug}, Organization: {ctx.meta['tb_config'].organization_slug}"
+    )
+
+    table.add_column("Task ID", no_wrap=True)
+    table.add_column("Created", no_wrap=True)
+    table.add_column("Name")
+    table.add_column("Status", no_wrap=True)
+    table.add_column("Percent", no_wrap=True)
+
+    for task in result.results:
+        table.add_row(task.id, task.created.isoformat(), task.name, task.status, str(task.value_percent))
+    Console().print(table)
+
+    cursor = _get_cursor(result.next_)
+    if cursor:
+        print(f"Next page token: [bold green]'{cursor}'[/]")
+
+
+def _render_csv(ctx, result):
+    writer = csv.writer(sys.stdout)
+    writer.writerow("Task ID,Created,Name,Status,Percent".split(","))
+    for task in result.results:
+        writer.writerow([task.id, task.created.isoformat(), task.name, task.status, str(task.value_percent)])
+
+    cursor = _get_cursor(result.next_)
+    if cursor:
+        print(f"next_token,{cursor}")
+
+
+def _render_json(ctx, result):
+    obj = result.to_dict()
+    ret = {"next_token": _get_cursor(result.next_), "results": obj["results"]}
+    print(json.dumps(ret, indent=2))
+
+
+def _get_cursor(url):
+    if url:
+        qs = urlparse(url).query
+        query = parse_qs(qs)
+        return query["cursor"][0]

taskbadger-0.8.0/taskbadger/cli/utils.py

@@ -0,0 +1,46 @@
+import json
+from enum import Enum
+
+import typer
+from rich import print
+from rich.console import Console
+
+from taskbadger import Action, integrations
+from taskbadger.exceptions import ConfigurationError
+
+
+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)
+
+
+err_console = Console(stderr=True)
+
+
+def get_actions(action_def: tuple[str, str, str]) -> list[Action]:
+    if any(action_def):
+        trigger, integration, config = action_def
+        return [Action(trigger, integrations.from_config(integration, config))]
+    return []
+
+
+def get_metadata(metadata_kv: list[str], metadata_json: str) -> dict:
+    metadata = {}
+    for kv in metadata_kv:
+        k, v = kv.strip().split("=", 1)
+        metadata[k] = v
+
+    if metadata_json:
+        metadata.update(json.loads(metadata_json))
+
+    return metadata
+
+
+class OutputFormat(str, Enum):
+    pretty = "pretty"
+    json = "json"
+    csv = "csv"

taskbadger-0.8.0/taskbadger/cli/wrapper.py

@@ -0,0 +1,82 @@
+from typing import Tuple
+
+import typer
+from rich import print
+
+from taskbadger import DefaultMergeStrategy, Session, StatusEnum, Task
+from taskbadger.cli.utils import configure_api, err_console, get_actions
+from taskbadger.process import ProcessRunner
+
+
+def run(
+    ctx: typer.Context,
+    name: str = typer.Argument(..., show_default=False, help="The task name"),
+    monitor_id: str = typer.Option(None, help="Associate this task with a monitor."),
+    update_frequency: int = typer.Option(5, metavar="SECONDS", min=5, max=300, help="Seconds between updates."),
+    action_def: Tuple[str, str, str] = typer.Option(
+        (None, None, None),
+        "--action",
+        "-a",
+        metavar="<trigger integration config>",
+        show_default=False,
+        help="Action definition e.g. 'success,error email to:me@email.com'",
+    ),
+    capture_output: bool = typer.Option(False, help="Capture stdout and stderr."),
+):
+    """Execute a command using the CLI and create a Task to track its outcome.
+
+    This command makes it easy to track a process's outcome using Task Badger.
+
+    It will create a Task prior to executing your command and will update
+    the Task status when you command exits.
+
+    Example:
+
+        [on black]taskbadger run 'my task' -- ./my-script.sh arg -v[/]
+    """
+    configure_api(ctx)
+    actions = get_actions(action_def)
+    stale_timeout = update_frequency * 2
+    with Session():
+        try:
+            task = Task.create(
+                name,
+                status=StatusEnum.PROCESSING,
+                stale_timeout=stale_timeout,
+                actions=actions,
+                monitor_id=monitor_id,
+            )
+        except Exception as e:
+            err_console.print(f"Error creating task: {e}")
+            task = None
+        else:
+            print(f"Task created: {task.public_url}")
+        env = {"TASKBADGER_TASK_ID": task.id} if task else None
+        try:
+            process = ProcessRunner(ctx.args, env, capture_output=capture_output, update_frequency=update_frequency)
+            for output in process.run():
+                _update_task(task, **(output or {}))
+        except Exception as e:
+            _update_task(task, exception=str(e))
+            raise typer.Exit(1)
+
+        if task:
+            if process.returncode == 0:
+                task.success(value=100)
+            else:
+                _update_task(task, status=StatusEnum.ERROR, return_code=process.returncode)
+
+    if process.returncode != 0:
+        raise typer.Exit(process.returncode)
+
+
+def _update_task(task, status=None, **data_kwargs):
+    """Update the task and merge the data"""
+    if not task:
+        return
+
+    merge_strategy = DefaultMergeStrategy(append_keys=("stdout", "stderr"))
+    try:
+        task.update(status=status, data=data_kwargs or None, data_merge_strategy=merge_strategy)
+    except Exception as e:
+        err_console.print(f"Error updating task status: {e!r}")

taskbadger-0.8.0/taskbadger/cli_main.py

@@ -0,0 +1,85 @@
+from typing import Optional
+
+import typer
+from rich import print
+
+from taskbadger import __version__
+from taskbadger.cli import create, get, list_tasks_command, run, update
+from taskbadger.config import get_config, write_config
+
+app = typer.Typer(
+    rich_markup_mode="rich",
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+
+
+app.command(context_settings={"allow_extra_args": True, "ignore_unknown_options": False})(run)
+app.command(context_settings={"ignore_unknown_options": False})(get)
+app.command(context_settings={"ignore_unknown_options": False})(create)
+app.command(context_settings={"ignore_unknown_options": False})(update)
+app.command("list", context_settings={"ignore_unknown_options": False})(list_tasks_command)
+
+
+def version_callback(value: bool):
+    if value:
+        print(f"Task Badger CLI Version: {__version__}")
+        raise typer.Exit()
+
+
+@app.command()
+def configure(ctx: typer.Context):
+    """Update CLI configuration."""
+    config = ctx.meta["tb_config"]
+    config.organization_slug = typer.prompt(f"Organization slug", default=config.organization_slug)
+    config.project_slug = typer.prompt(f"Project slug", default=config.project_slug)
+    config.token = typer.prompt(f"API Key", default=config.token)
+    path = write_config(config)
+    print(f"Config written to [green]{path}[/green]")
+
+
+@app.command()
+def docs():
+    """Open Task Badger docs in a browser."""
+    typer.launch("https://docs.taskbadger.net")
+
+
+@app.command()
+def info(ctx: typer.Context):
+    """Show CLI configuration."""
+    config = ctx.meta["tb_config"]
+    print(str(config))
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    org: Optional[str] = typer.Option(
+        None,
+        "--org",
+        "-o",
+        metavar="TASKBADGER_ORG",
+        show_default=False,
+        help="Organization Slug. This will override values from the config file and environment variables.",
+    ),
+    project: Optional[str] = typer.Option(
+        None,
+        "--project",
+        "-p",
+        show_envvar=False,
+        metavar="TASKBADGER_PROJECT",
+        show_default=False,
+        help="Project Slug. This will override values from the config file and environment variables.",
+    ),
+    version: Optional[bool] = typer.Option(  # noqa
+        None, "--version", callback=version_callback, is_eager=True, help="Show CLI Version"
+    ),
+):
+    """
+    Task Badger CLI
+    """
+    config = get_config(org=org, project=project)
+    ctx.meta["tb_config"] = config
+
+
+if __name__ == "__main__":
+    app()

taskbadger-0.8.0/taskbadger/exceptions.py

@@ -0,0 +1,26 @@
+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)}"
+
+
+class TaskbadgerException(Exception):
+    pass
+
+
+class Unauthorized(TaskbadgerException):
+    pass
+
+
+class UnexpectedStatus(TaskbadgerException):
+    def __init__(self, status_code: int, content: bytes):
+        self.status_code = status_code
+        self.content = content
+
+        super().__init__(f"Unexpected status code: {status_code}")
+
+
+class ServerError(UnexpectedStatus):
+    pass

taskbadger-0.8.0/taskbadger/integrations.py

@@ -0,0 +1,78 @@
+import dataclasses
+from typing import Any, Dict
+
+from taskbadger.exceptions import TaskbadgerException
+from taskbadger.internal.models import ActionRequest, ActionRequestConfig
+
+
+def from_config(integration_id: str, config: str):
+    cls = integration_from_id(integration_id)
+    return cls.from_config_string(integration_id, config)
+
+
+class Integration:
+    type: str
+    id: str
+
+    def __post_init__(self):
+        if not self.id.startswith(self.type):
+            raise TaskbadgerException(f"Expected integration ID '{self.id}' to start with '{self.type}'")
+
+    def request_config(self):
+        raise NotImplementedError
+
+    @classmethod
+    def from_config_string(cls, integration_id, config):
+        kwargs = {"id": integration_id}
+        if config:
+            # convert config string to dict
+            # "to:me@me.com,from:you@you.com"
+            split_ = [tuple(item.split(":", 1)) for item in config.split(",")]
+            kwargs.update(dict(split_))
+        return cls(**kwargs)
+
+
+@dataclasses.dataclass
+class Action:
+    trigger: str
+    integration: Integration
+
+    def to_dict(self) -> Dict[str, Any]:
+        return ActionRequest(self.trigger, self.integration.id, self.integration.request_config()).to_dict()
+
+
+@dataclasses.dataclass
+class EmailIntegration(Integration):
+    type = "email"
+    to: str  # custom type
+    id: str = "email"
+
+    def request_config(self) -> ActionRequestConfig:
+        return ActionRequestConfig.from_dict({"to": self.to})
+
+
+@dataclasses.dataclass
+class WebhookIntegration(Integration):
+    type = "webhook"
+    id: str
+
+    def request_config(self) -> ActionRequestConfig:
+        return ActionRequestConfig.from_dict({})
+
+
+ALL = [EmailIntegration, WebhookIntegration]
+BY_TYPE = {cls.type: cls for cls in ALL}
+
+
+def integration_from_id(integration_id):
+    type_, _ = get_type_id(integration_id)
+    try:
+        return BY_TYPE[type_]
+    except KeyError:
+        raise TaskbadgerException(f"Unknown integration type: '{type_}'")
+
+
+def get_type_id(integration_id: str):
+    if ":" in integration_id:
+        return integration_id.split(":", 1)
+    return integration_id, None

{taskbadger-0.4.4 → taskbadger-0.8.0}/taskbadger/internal/__init__.py

@@ -1,4 +1,4 @@
-""" A client library for accessing Task Badger """
+""" A client library for accessing Taskbadger API """
 from .client import AuthenticatedClient, Client
 
 __all__ = (