clockify-unofficial-cli 0.2.0__py3-none-any.whl

clockify_unofficial_cli/config/store.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import tomllib
+from tempfile import NamedTemporaryFile
+from typing import TYPE_CHECKING
+from typing import Final
+
+import tomli_w
+from pydantic import ValidationError
+
+from clockify_unofficial_cli.config.settings import Settings
+from clockify_unofficial_cli.runtime.errors import CliError
+from clockify_unofficial_cli.runtime.exit_codes import ExitCode
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+PRIVATE_FILE_MODE: Final = 0o600
+PRIVATE_DIR_MODE: Final = 0o700
+
+
+def read_toml(path: Path) -> dict[str, object]:
+    try:
+        with path.open("rb") as handle:
+            return tomllib.load(handle)
+    except FileNotFoundError:
+        return {}
+    except tomllib.TOMLDecodeError as error:
+        message = f"Cannot parse {path}: {error}"
+        raise CliError(message, exit_code=ExitCode.CONFIGURATION) from error
+
+
+# Written to a sibling temp file and renamed so a crash never leaves a half-written file,
+# and created 0600 from the start so secrets are never briefly world-readable.
+def write_private_toml(path: Path, data: dict[str, object]) -> None:
+    path.parent.mkdir(mode=PRIVATE_DIR_MODE, parents=True, exist_ok=True)
+    with NamedTemporaryFile("wb", dir=path.parent, prefix=f".{path.name}.", delete=False) as handle:
+        tomli_w.dump(data, handle)
+    temp_path = path.parent / handle.name
+    temp_path.chmod(PRIVATE_FILE_MODE)
+    temp_path.replace(path)
+
+
+class SettingsStore:
+    def __init__(self, path: Path) -> None:
+        self.path = path
+
+    def load(self) -> Settings:
+        try:
+            return Settings.model_validate(read_toml(self.path))
+        except ValidationError as error:
+            message = f"Invalid settings in {self.path}: {error.error_count()} problem(s)"
+            raise CliError(message, exit_code=ExitCode.CONFIGURATION, hint=str(error)) from error
+
+    def save(self, settings: Settings) -> None:
+        write_private_toml(self.path, settings.model_dump(mode="json", exclude_none=True))

clockify_unofficial_cli/main.py

@@ -0,0 +1,131 @@
+import os
+import sys
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+from typing import Annotated
+from typing import Final
+
+import typer
+from rich.console import Console
+
+from clockify_unofficial_cli._version import __version__
+from clockify_unofficial_cli.auth.env_store import EnvCredentialStore
+from clockify_unofficial_cli.auth.file_store import FileCredentialStore
+from clockify_unofficial_cli.auth.keyring_store import KeyringCredentialStore
+from clockify_unofficial_cli.auth.resolver import CredentialStores
+from clockify_unofficial_cli.commands import auth
+from clockify_unofficial_cli.commands import client
+from clockify_unofficial_cli.commands import config
+from clockify_unofficial_cli.commands import custom_field
+from clockify_unofficial_cli.commands import entry
+from clockify_unofficial_cli.commands import group
+from clockify_unofficial_cli.commands import project
+from clockify_unofficial_cli.commands import tag
+from clockify_unofficial_cli.commands import task
+from clockify_unofficial_cli.commands import timer_shortcuts
+from clockify_unofficial_cli.commands import user
+from clockify_unofficial_cli.commands import workspace
+from clockify_unofficial_cli.config.paths import credentials_file
+from clockify_unofficial_cli.config.paths import settings_file
+from clockify_unofficial_cli.config.settings import GlobalOptions
+from clockify_unofficial_cli.config.settings import OutputFormat
+from clockify_unofficial_cli.config.settings import resolve_options
+from clockify_unofficial_cli.config.store import SettingsStore
+from clockify_unofficial_cli.output.registry import create_renderer
+from clockify_unofficial_cli.output.renderer import RenderTarget
+from clockify_unofficial_cli.runtime.client_factory import create_sdk_client
+from clockify_unofficial_cli.runtime.context import AppContext
+from clockify_unofficial_cli.runtime.context import Services
+from clockify_unofficial_cli.runtime.errors import handle_errors
+from clockify_unofficial_cli.runtime.params import options_from
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+def default_services() -> Services:
+    return Services(
+        settings=SettingsStore(settings_file()),
+        credentials=CredentialStores(
+            environment=EnvCredentialStore(os.environ),
+            keyring=KeyringCredentialStore(),
+            file=FileCredentialStore(credentials_file()),
+        ),
+        clients=create_sdk_client,
+    )
+
+
+def print_version(
+    value: bool,  # ruff: ignore[boolean-type-hint-positional-argument]  Typer passes the flag value positionally
+) -> None:
+    if value:
+        typer.echo(f"clockify {__version__}")
+        raise typer.Exit
+
+
+@dataclass(frozen=True, slots=True)
+class _RootOptions:
+    profile: Annotated[
+        str | None,
+        typer.Option("--profile", "-p", envvar="CLOCKIFY_PROFILE", help="Configuration profile to use."),
+    ] = None
+    workspace: Annotated[
+        str | None,
+        typer.Option("--workspace", "-w", envvar="CLOCKIFY_WORKSPACE", help="Workspace ID; overrides the profile."),
+    ] = None
+    output: Annotated[
+        OutputFormat | None,
+        typer.Option("--output", "-o", envvar="CLOCKIFY_OUTPUT", case_sensitive=False, help="Output format."),
+    ] = None
+    verbose: Annotated[
+        bool,
+        typer.Option("--verbose", "-v", help="Print HTTP request diagnostics to stderr."),
+    ] = False
+    version: Annotated[
+        bool,
+        typer.Option("--version", callback=print_version, is_eager=True, help="Show the version and exit."),
+    ] = False
+
+
+# Global options must precede the sub-command (`clockify -o json auth status`). Colors follow
+# Rich's NO_COLOR handling, so there is no --no-color flag to keep the callback small.
+def create_app(services_factory: Callable[[], Services] = default_services) -> typer.Typer:
+    cli = typer.Typer(name="clockify", help="Unofficial command-line interface for Clockify.", no_args_is_help=True)
+
+    @cli.callback()
+    @handle_errors
+    @options_from(_RootOptions)
+    def root(ctx: typer.Context, options: _RootOptions) -> None:
+        flags = GlobalOptions(
+            profile=options.profile, workspace=options.workspace, output=options.output, verbose=options.verbose
+        )
+        _bind_context(ctx=ctx, services=services_factory(), flags=flags)
+
+    def _bind_context(*, ctx: typer.Context, services: Services, flags: GlobalOptions) -> None:
+        resolved = resolve_options(flags, services.settings.load(), is_tty=sys.stdout.isatty())
+        console = Console(highlight=False)
+        renderer = create_renderer(resolved.output, RenderTarget(console=console, stream=sys.stdout))
+        app_context = AppContext(options=resolved, services=services, console=console, renderer=renderer)
+        ctx.obj = app_context
+        ctx.call_on_close(app_context.close)
+
+    cli.add_typer(auth.APP, name="auth")
+    cli.add_typer(config.APP, name="config")
+    cli.add_typer(workspace.APP, name="workspace")
+    cli.add_typer(user.APP, name="user")
+    cli.add_typer(client.APP, name="client")
+    cli.add_typer(project.APP, name="project")
+    cli.add_typer(tag.APP, name="tag")
+    cli.add_typer(task.APP, name="task")
+    cli.add_typer(custom_field.APP, name="custom-field")
+    cli.add_typer(group.APP, name="group")
+    cli.add_typer(entry.APP, name="entry")
+    cli.registered_commands.extend(timer_shortcuts.APP.registered_commands)
+    return cli
+
+
+APP: Final = create_app()
+
+
+def run() -> None:
+    APP(prog_name="clockify")

clockify_unofficial_cli/output/columns.py

@@ -0,0 +1,88 @@
+from typing import Final
+
+from clockify_unofficial_cli.output.renderer import Column
+
+AUTH_STATUS: Final = (
+    Column("profile", "Profile"),
+    Column("name", "User"),
+    Column("email", "Email"),
+    Column("workspaceId", "Workspace"),
+    Column("region", "Region"),
+    Column("source", "Credential source"),
+    Column("apiKey", "API key"),
+)
+
+PROFILES: Final = (
+    Column("name", "Profile"),
+    Column("default", "Default"),
+    Column("region", "Region"),
+    Column("workspaceId", "Workspace"),
+    Column("email", "Email"),
+)
+
+WORKSPACES: Final = (
+    Column("id", "ID"),
+    Column("name", "Name"),
+)
+
+USERS: Final = (
+    Column("id", "ID"),
+    Column("name", "Name"),
+    Column("email", "Email"),
+    Column("status", "Status"),
+)
+
+CLIENTS: Final = (
+    Column("id", "ID"),
+    Column("name", "Name"),
+    Column("email", "Email"),
+    Column("archived", "Archived"),
+)
+
+PROJECTS_LIST: Final = (
+    Column("id", "ID"),
+    Column("name", "Name"),
+    Column("clientId", "Client"),
+    Column("public", "Public"),
+    Column("billable", "Billable"),
+    Column("archived", "Archived"),
+)
+
+TAGS: Final = (
+    Column("id", "ID"),
+    Column("name", "Name"),
+    Column("archived", "Archived"),
+)
+
+TASKS: Final = (
+    Column("id", "ID"),
+    Column("name", "Name"),
+    Column("status", "Status"),
+    Column("assigneeIds", "Assignees"),
+    Column("estimate", "Estimate"),
+)
+
+CUSTOM_FIELDS: Final = (
+    Column("id", "ID"),
+    Column("name", "Name"),
+    Column("type", "Type"),
+    Column("entityType", "Entity"),
+    Column("status", "Status"),
+)
+
+GROUPS: Final = (
+    Column("id", "ID"),
+    Column("name", "Name"),
+    Column("userIds", "Members"),
+)
+
+TIME_ENTRIES: Final = (
+    Column("id", "ID"),
+    Column("description", "Description"),
+    Column("projectId", "Project"),
+    Column("taskId", "Task"),
+    Column("timeInterval.start", "Start"),
+    Column("timeInterval.end", "End"),
+    Column("timeInterval.duration", "Duration"),
+    Column("billable", "Billable"),
+)

clockify_unofficial_cli/output/formats.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import csv
+import json
+from typing import TYPE_CHECKING
+
+from rich.table import Table
+
+if TYPE_CHECKING:
+    from clockify_unofficial_cli.output.renderer import Dataset
+    from clockify_unofficial_cli.output.renderer import RenderTarget
+
+
+def _cell(value: object) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, bool):
+        return "yes" if value else "no"
+    if isinstance(value, (dict, list)):
+        return json.dumps(value)
+    return str(value)
+
+
+class TableRenderer:
+    def __init__(self, target: RenderTarget) -> None:
+        self._console = target.console
+
+    def render(self, dataset: Dataset) -> None:
+        if dataset.single and dataset.records:
+            table = Table(show_header=False, box=None)
+            table.add_column(style="bold")
+            table.add_column()
+            for column in dataset.columns:
+                table.add_row(column.header, _cell(column.value(dataset.records[0])))
+        else:
+            table = Table()
+            for column in dataset.columns:
+                table.add_column(column.header)
+            for record in dataset.records:
+                table.add_row(*(_cell(column.value(record)) for column in dataset.columns))
+        self._console.print(table)
+
+
+class JsonRenderer:
+    def __init__(self, target: RenderTarget) -> None:
+        self._stream = target.stream
+
+    def render(self, dataset: Dataset) -> None:
+        payload = dataset.records[0] if dataset.single and dataset.records else list(dataset.records)
+        self._stream.write(json.dumps(payload, indent=2, ensure_ascii=False) + "\n")
+
+
+class JsonLinesRenderer:
+    def __init__(self, target: RenderTarget) -> None:
+        self._stream = target.stream
+
+    def render(self, dataset: Dataset) -> None:
+        for record in dataset.records:
+            self._stream.write(json.dumps(record, ensure_ascii=False) + "\n")
+
+
+class CsvRenderer:
+    def __init__(self, target: RenderTarget) -> None:
+        self._stream = target.stream
+
+    def render(self, dataset: Dataset) -> None:
+        writer = csv.writer(self._stream, lineterminator="\n")
+        writer.writerow(column.header for column in dataset.columns)
+        for record in dataset.records:
+            writer.writerow(_cell(column.value(record)) for column in dataset.columns)
+
+
+# Bare identifiers, one per line, for `xargs`/`$(...)` pipelines.
+class IdRenderer:
+    def __init__(self, target: RenderTarget) -> None:
+        self._stream = target.stream
+
+    def render(self, dataset: Dataset) -> None:
+        for record in dataset.records:
+            identifier = record.get("id")
+            if identifier is not None:
+                self._stream.write(f"{identifier}\n")

clockify_unofficial_cli/output/registry.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from typing import Final
+
+from clockify_unofficial_cli.config.settings import OutputFormat
+from clockify_unofficial_cli.output.formats import CsvRenderer
+from clockify_unofficial_cli.output.formats import IdRenderer
+from clockify_unofficial_cli.output.formats import JsonLinesRenderer
+from clockify_unofficial_cli.output.formats import JsonRenderer
+from clockify_unofficial_cli.output.formats import TableRenderer
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from clockify_unofficial_cli.output.renderer import RenderTarget
+    from clockify_unofficial_cli.output.renderer import Renderer
+
+_RENDERERS: Final[dict[OutputFormat, Callable[[RenderTarget], Renderer]]] = {
+    OutputFormat.TABLE: TableRenderer,
+    OutputFormat.JSON: JsonRenderer,
+    OutputFormat.JSONL: JsonLinesRenderer,
+    OutputFormat.CSV: CsvRenderer,
+    OutputFormat.ID: IdRenderer,
+}
+
+
+def create_renderer(output: OutputFormat, target: RenderTarget) -> Renderer:
+    return _RENDERERS[output](target)

clockify_unofficial_cli/output/renderer.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from dataclasses import field
+from typing import TYPE_CHECKING
+from typing import Protocol
+
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from collections.abc import Sequence
+    from typing import TextIO
+
+    from rich.console import Console
+
+type Record = Mapping[str, object]  # pylint: disable=gajaguar-module-const-naming
+
+
+@dataclass(frozen=True, slots=True)
+class Column:
+    key: str
+    header: str
+
+    # Keys may be dotted paths into nested API objects, e.g. "timeInterval.duration".
+    def value(self, record: Record) -> object:
+        current: object = record
+        for part in self.key.split("."):
+            if not isinstance(current, Mapping):
+                return None
+            current = current.get(part)
+        return current
+
+
+@dataclass(frozen=True, slots=True)
+class Dataset:
+    records: Sequence[Record]
+    columns: Sequence[Column]
+    single: bool = False
+
+
+@dataclass(frozen=True, slots=True)
+class RenderTarget:
+    console: Console
+    stream: TextIO = field(repr=False)
+
+
+class Renderer(Protocol):
+    def render(self, dataset: Dataset) -> None: ...
+
+
+# JSON output keeps Clockify's camelCase field names so it lines up with the API docs.
+def to_record(item: BaseModel | Record | object) -> Record:
+    if isinstance(item, BaseModel):
+        return item.model_dump(mode="json", by_alias=True)
+    if isinstance(item, Mapping):
+        return item
+    message = f"Cannot coerce {type(item).__name__} to a renderer record."
+    raise TypeError(message)
+
+
+def many(items: Iterable[BaseModel | Record], columns: Sequence[Column]) -> Dataset:
+    return Dataset(records=[to_record(item) for item in items], columns=columns)
+
+
+def single(item: BaseModel | Record, columns: Sequence[Column]) -> Dataset:
+    return Dataset(records=[to_record(item)], columns=columns, single=True)

clockify_unofficial_cli/runtime/client_factory.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import sys
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from clockify import ClientOptions
+from clockify import ClockifyClient
+from clockify import Region
+
+if TYPE_CHECKING:
+    from clockify_unofficial_cli.auth.credentials import Credential
+
+
+# Per-invocation bundle so the client factory can build a verbose request hook without
+# growing a long positional argument list every time a new flag appears.
+@dataclass(frozen=True, slots=True)
+class ClientRequest:
+    credential: Credential
+    region: Region
+    verbose: bool = False
+
+
+type ClientFactory = Callable[[ClientRequest], ClockifyClient]  # pylint: disable=gajaguar-module-const-naming
+
+
+def _log_response(response: object) -> None:
+    raw_request = getattr(response, "request", None)
+    method = getattr(raw_request, "method", "?")
+    url = str(getattr(raw_request, "url", "?"))
+    status = getattr(response, "status_code", "?")
+    sys.stderr.write(f"-> {method} {url} {status}\n")
+    sys.stderr.flush()
+
+
+def create_sdk_client(request: ClientRequest) -> ClockifyClient:
+    event_hooks: dict[str, list[Callable[..., object]]] | None = (
+        {"response": [_log_response]} if request.verbose else None
+    )
+    options = ClientOptions(region=request.region, event_hooks=event_hooks)
+    return ClockifyClient(api_key=request.credential.api_key, options=options)

clockify_unofficial_cli/runtime/context.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from dataclasses import field
+from typing import TYPE_CHECKING
+
+from clockify import UserId
+from rich.console import Console
+
+from clockify_unofficial_cli.runtime.client_factory import ClientRequest
+from clockify_unofficial_cli.runtime.errors import CliError
+from clockify_unofficial_cli.runtime.exit_codes import ExitCode
+
+if TYPE_CHECKING:
+    import typer
+    from clockify import ClockifyClient
+    from clockify import WorkspaceClient
+
+    from clockify_unofficial_cli.auth.credentials import ResolvedCredential
+    from clockify_unofficial_cli.auth.resolver import CredentialStores
+    from clockify_unofficial_cli.config.settings import ResolvedOptions
+    from clockify_unofficial_cli.config.store import SettingsStore
+    from clockify_unofficial_cli.output.renderer import Dataset
+    from clockify_unofficial_cli.output.renderer import Renderer
+    from clockify_unofficial_cli.runtime.client_factory import ClientFactory
+
+
+@dataclass(frozen=True, slots=True)
+class Services:
+    settings: SettingsStore
+    credentials: CredentialStores
+    clients: ClientFactory
+
+
+# Built once per invocation by the root callback and shared with every command through
+# typer.Context.obj; the SDK client is created lazily so offline commands never need a key.
+@dataclass(slots=True)
+class AppContext:
+    options: ResolvedOptions
+    services: Services
+    console: Console
+    renderer: Renderer
+    _client: ClockifyClient | None = field(default=None, init=False, repr=False)
+    _user_id: UserId | None = field(default=None, init=False, repr=False)
+
+    def credential(self) -> ResolvedCredential:
+        resolved = self.services.credentials.resolve(self.options.profile_name)
+        if resolved is None:
+            message = f"Not logged in (profile '{self.options.profile_name}')."
+            hint = "Run `clockify auth login` or set CLOCKIFY_API_KEY."
+            raise CliError(message, exit_code=ExitCode.CONFIGURATION, hint=hint)
+        return resolved
+
+    def client(self) -> ClockifyClient:
+        if self._client is None:
+            credential = self.credential().credential
+            request = ClientRequest(
+                credential=credential,
+                region=self.options.profile.region,
+                verbose=self.options.verbose,
+            )
+            self._client = self.services.clients(request)
+        return self._client
+
+    def user_id(self) -> UserId:
+        if self._user_id is None:
+            cached = self.options.profile.user_id
+            if cached is not None:
+                self._user_id = UserId(cached)
+            else:
+                self._user_id = self.client().user.me().id
+        return self._user_id
+
+    def workspace(self) -> WorkspaceClient:
+        if self.options.workspace_id:
+            return self.client().workspace(self.options.workspace_id)
+        return self.client().default_workspace()
+
+    # Status messages go to stderr so stdout stays clean for piping rendered data.
+    @staticmethod
+    def notify(message: str) -> None:
+        Console(stderr=True, highlight=False).print(message, markup=False)
+
+    def render(self, dataset: Dataset) -> None:
+        self.renderer.render(dataset)
+
+    def close(self) -> None:
+        if self._client is not None:
+            self._client.close()
+            self._client = None
+        self._user_id = None
+
+
+def get_app_context(ctx: typer.Context) -> AppContext:
+    obj: object = ctx.find_root().obj
+    if not isinstance(obj, AppContext):
+        message = "CLI context is not initialized."
+        raise CliError(message)
+    return obj

clockify_unofficial_cli/runtime/errors.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from functools import wraps
+from typing import TYPE_CHECKING
+from typing import Final
+
+import typer
+from clockify.errors import AuthenticationError
+from clockify.errors import ClockifyAPIError
+from clockify.errors import ClockifyError
+from clockify.errors import ConfigurationError
+from clockify.errors import ConflictError
+from clockify.errors import ForbiddenError
+from clockify.errors import NotFoundError
+from clockify.errors import RateLimitError
+from clockify.errors import ServerError
+from clockify.errors import TransportError
+from clockify.errors import ValidationError
+from rich.console import Console
+from rich.markup import escape
+
+from clockify_unofficial_cli.runtime.exit_codes import ExitCode
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+class CliError(Exception):
+    def __init__(self, message: str, *, exit_code: ExitCode = ExitCode.FAILURE, hint: str | None = None) -> None:
+        super().__init__(message)
+        self.message = message
+        self.exit_code = exit_code
+        self.hint = hint
+
+
+# Ordered most-specific first: the first isinstance match wins.
+_SDK_EXIT_CODES: Final[tuple[tuple[type[ClockifyError], ExitCode], ...]] = (
+    (ConfigurationError, ExitCode.CONFIGURATION),
+    (AuthenticationError, ExitCode.AUTHENTICATION),
+    (ForbiddenError, ExitCode.FORBIDDEN),
+    (NotFoundError, ExitCode.NOT_FOUND),
+    (ValidationError, ExitCode.VALIDATION),
+    (ConflictError, ExitCode.VALIDATION),
+    (RateLimitError, ExitCode.RATE_LIMITED),
+    (ServerError, ExitCode.UNAVAILABLE),
+    (TransportError, ExitCode.UNAVAILABLE),
+)
+
+_SDK_HINTS: Final[dict[ExitCode, str]] = {
+    ExitCode.AUTHENTICATION: "Run `clockify auth login` to store a valid API key.",
+    ExitCode.RATE_LIMITED: "Clockify rate limit reached after retries; try again shortly.",
+}
+
+
+def exit_code_for(error: ClockifyError) -> ExitCode:
+    for error_type, exit_code in _SDK_EXIT_CODES:
+        if isinstance(error, error_type):
+            return exit_code
+    return ExitCode.FAILURE
+
+
+def describe(error: ClockifyError) -> str:
+    detail = error.message or type(error).__name__
+    if isinstance(error, ClockifyAPIError) and error.status_code:
+        return f"{detail} (HTTP {error.status_code})"
+    return detail
+
+
+def report(message: str, hint: str | None = None) -> None:
+    console = Console(stderr=True, highlight=False)
+    console.print(f"[bold red]error:[/] {escape(message)}")
+    if hint:
+        console.print(f"[dim]hint:[/] {escape(hint)}")
+
+
+def handle_errors[**P, R](func: Callable[P, R]) -> Callable[P, R]:
+    @wraps(func)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        try:
+            return func(*args, **kwargs)
+        except CliError as error:
+            report(error.message, error.hint)
+            raise typer.Exit(error.exit_code) from error
+        except ClockifyError as error:
+            exit_code = exit_code_for(error)
+            report(describe(error), _SDK_HINTS.get(exit_code))
+            raise typer.Exit(exit_code) from error
+
+    return wrapper