databay-cli 0.1.0__py3-none-any.whl

databay/profiles.py

@@ -0,0 +1,181 @@
+"""
+Profiles: which server a command talks to, how it gets its token, and its active project.
+
+``config.toml`` in the config dir::
+
+    current_profile = "staging"
+
+    [profiles.staging]
+    server = "https://databay.example.com"
+    auth = "login"                     # login, api_key or env
+    credential = "databay-cli:https://databay.example.com:<sub>"
+    token_store = "keyring"            # keyring or file
+    active_project = "<project id>"    # optional
+
+The profile alone picks the token: ``login`` and ``api_key`` read the stored ``credential``
+(written by ``databay login``), ``env`` reads ``$DATABAY_TOKEN``. A command uses ``--profile NAME``,
+else ``current_profile``; with neither it fails with ``no_profile``. A key this version does not
+know is an error, never ignored. Writers hold the config lock and replace the file whole.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import tomllib
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from databay.errors import DatabayProfileError, DatabayUsageError
+from databay.locks import CONFIG_LOCK, locked
+from databay.paths import config_file
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from pathlib import Path
+
+PROFILE_KEYS = frozenset({"server", "auth", "credential", "token_store", "active_project"})
+TOP_LEVEL_KEYS = frozenset({"current_profile", "profiles"})
+#: The order a written profile lists its keys in.
+KEY_ORDER = ("server", "auth", "credential", "token_store", "active_project")
+#: The token sources that read a stored credential.
+STORED_AUTH = frozenset({"login", "api_key"})
+PROFILE_NAME = re.compile(r"^[A-Za-z0-9_-]{1,64}$")
+
+
+@dataclass(frozen=True, slots=True)
+class Profile:
+    name: str
+    server: str
+    auth: str
+    active_project: str | None = None
+    credential: str | None = None
+    token_store: str | None = None
+
+
+def _invalid(path: Path, problem: str) -> DatabayProfileError:
+    return DatabayProfileError(f"{path}: {problem}", code="profile_invalid")
+
+
+def _read(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        return {}
+    try:
+        data = tomllib.loads(path.read_text(encoding="utf-8"))
+    except tomllib.TOMLDecodeError as exc:
+        raise _invalid(path, f"not valid TOML ({exc})") from exc
+    unknown = sorted(set(data) - TOP_LEVEL_KEYS)
+    if unknown:
+        raise _invalid(path, f"unknown keys {unknown}; allowed: {sorted(TOP_LEVEL_KEYS)}")
+    if not isinstance(data.get("profiles", {}), dict):
+        raise _invalid(path, "profiles is not a table")
+    return data
+
+
+def _optional_text(path: Path, name: str, entry: dict[str, Any], key: str) -> str | None:
+    value = entry.get(key)
+    if value is not None and (not isinstance(value, str) or not value):
+        raise _invalid(path, f"profiles.{name}.{key} must be a non-empty string")
+    return value
+
+
+def _profile(path: Path, name: str, entry: Any) -> Profile:  # noqa: ANN401 — a parsed TOML value
+    from databay.credentials import TOKEN_STORES  # noqa: PLC0415
+    from databay.tokens import TOKEN_SOURCES  # noqa: PLC0415 — tokens imports this module's types
+
+    if not isinstance(entry, dict):
+        raise _invalid(path, f"profiles.{name} is not a table")
+    unknown = sorted(set(entry) - PROFILE_KEYS)
+    if unknown:
+        raise _invalid(path, f"profiles.{name} has unknown keys {unknown}; allowed: {sorted(PROFILE_KEYS)}")
+    server = entry.get("server")
+    if not isinstance(server, str) or not server.startswith(("https://", "http://")):
+        raise _invalid(path, f"profiles.{name}.server must be an http(s) URL, got {server!r}")
+    auth = entry.get("auth")
+    if auth not in TOKEN_SOURCES:
+        raise _invalid(path, f"profiles.{name}.auth must be one of {sorted(TOKEN_SOURCES)}, got {auth!r}")
+    project = _optional_text(path, name, entry, "active_project")
+    credential = _optional_text(path, name, entry, "credential")
+    store = _optional_text(path, name, entry, "token_store")
+    if auth not in STORED_AUTH and (credential or store):
+        raise _invalid(
+            path, f"profiles.{name} has auth = {auth!r}, which stores nothing: remove credential and token_store"
+        )
+    if (credential is not None or store is not None) and store not in TOKEN_STORES:
+        raise _invalid(path, f"profiles.{name}.token_store must be one of {list(TOKEN_STORES)}, got {store!r}")
+    return Profile(
+        name=name,
+        server=server.rstrip("/"),
+        auth=auth,
+        active_project=project,
+        credential=credential,
+        token_store=store,
+    )
+
+
+def load_profile(name: str | None) -> Profile:
+    """The profile ``name``, else the config's ``current_profile``; ``no_profile`` when there is neither."""
+    path = config_file()
+    data = _read(path)
+    chosen = name or data.get("current_profile")
+    if chosen is None:
+        raise DatabayProfileError(
+            f"no profile: pass --profile NAME or sign in with databay login --server URL (config: {path})"
+        )
+    profiles = data.get("profiles", {})
+    if chosen not in profiles:
+        known = ", ".join(sorted(profiles)) or "none"
+        raise DatabayProfileError(f"no profile {chosen!r} in {path} (profiles: {known})")
+    return _profile(path, chosen, profiles[chosen])
+
+
+def all_profiles() -> tuple[str | None, list[Profile]]:
+    """``current_profile`` and every profile, by name."""
+    path = config_file()
+    data = _read(path)
+    profiles = data.get("profiles", {})
+    return data.get("current_profile"), [_profile(path, name, profiles[name]) for name in sorted(profiles)]
+
+
+def _toml(data: dict[str, Any]) -> str:
+    """``config.toml`` text: strings only, every value JSON-quoted (a JSON string is a TOML basic string)."""
+    lines = []
+    if data.get("current_profile") is not None:
+        lines += [f"current_profile = {json.dumps(data['current_profile'])}", ""]
+    for name, entry in sorted(data.get("profiles", {}).items()):
+        lines.append(f"[profiles.{json.dumps(name)}]")
+        lines += [f"{key} = {json.dumps(entry[key])}" for key in KEY_ORDER if entry.get(key) is not None]
+        lines.append("")
+    return "\n".join(lines)
+
+
+def edit_config(change: Callable[[dict[str, Any]], Any]) -> Any:  # noqa: ANN401 — what ``change`` returns
+    """
+    Apply ``change`` to the parsed config under the config lock, then write it; returns what ``change`` returns.
+
+    The result is validated before it is written, so a change never leaves a config this version cannot read.
+    """
+    path = config_file()
+    with locked(CONFIG_LOCK):
+        data = _read(path)
+        data.setdefault("profiles", {})
+        outcome = change(data)
+        for name, entry in data["profiles"].items():
+            _profile(path, name, entry)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = path.with_suffix(f".{os.getpid()}.tmp")
+        tmp.write_text(_toml(data), encoding="utf-8")
+        tmp.replace(path)
+    return outcome
+
+
+def login_command(profile: Profile) -> str:
+    """The command that signs ``profile`` in again."""
+    return f"databay login --server {profile.server} --profile {profile.name}"
+
+
+def check_name(name: str) -> str:
+    if not PROFILE_NAME.match(name):
+        raise DatabayUsageError(f"profile name {name!r}: use 1 to 64 letters, digits, - or _")
+    return name

databay/redact.py

@@ -0,0 +1,22 @@
+"""What ``--verbose`` may print of a request: secret headers and secret body fields are replaced."""
+
+from __future__ import annotations
+
+from typing import Any
+
+REDACTED = "<redacted>"
+#: Lower case: header names are case-insensitive.
+SECRET_HEADERS = frozenset({"authorization", "cookie", "set-cookie", "proxy-authorization"})
+
+
+def headers(values: dict[str, str]) -> dict[str, str]:
+    return {name: REDACTED if name.lower() in SECRET_HEADERS else value for name, value in values.items()}
+
+
+def body(value: Any, secret_fields: frozenset[str]) -> Any:  # noqa: ANN401 — any JSON value
+    """``value`` with every field named in ``secret_fields`` replaced, at any depth."""
+    if isinstance(value, dict):
+        return {k: REDACTED if k in secret_fields else body(v, secret_fields) for k, v in value.items()}
+    if isinstance(value, list):
+        return [body(item, secret_fields) for item in value]
+    return value

databay/reference.py

@@ -0,0 +1,218 @@
+"""
+The text of each command's ``--help`` and of the generated ``commands.md`` and ``errors.md``.
+
+``--help`` and the references are rendered by the same functions from the same ``Operation``
+data, so they cannot drift. Standard library only: ``python/tools/gen_client.py`` renders the
+references with it.
+"""
+
+from __future__ import annotations
+
+import inspect
+from typing import TYPE_CHECKING, Any
+
+from databay.cli.flags import Flag, command_flags
+from databay.error_catalog import EXIT_CODES, LOCAL_CODES, server_exit
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from databay.operation import Operation
+
+GENERATED_NOTE = "Generated by python/tools/gen_client.py from contract/core.json; do not edit."
+
+
+def _description(op: Operation) -> str:
+    text = inspect.cleandoc(op.description) if op.description.strip() else ""
+    return text or op.summary
+
+
+def help_paragraphs(op: Operation, variant: str | None = None) -> list[tuple[str, bool]]:
+    """``(text, preformatted)`` paragraphs of a command's help; examples keep their lines."""
+    paragraphs: list[tuple[str, bool]] = [(part, False) for part in _description(op).split("\n\n") if part.strip()]
+    location = op.project_location
+    if location is not None:
+        where = "the X-Databay-Project-ID header" if location[0] == "header" else f"{location[0]} {location[1]}"
+        paragraphs.append((f"Acts in a project, sent as {where}: --project, else the profile's active project.", False))
+    if op.destructive:
+        paragraphs.append(
+            ("Removes or overwrites state: asks on a terminal, and needs --yes when output is captured.", False)
+        )
+    wait = op.wait or op.resumes
+    if wait is not None and not op.offers_wait:
+        paragraphs.append(("Answers at once: `next` names the command that waits for it.", False))
+    elif wait is not None:
+        text = (
+            f"--wait polls {wait.status_operation} until {wait.field.lstrip('/')} is "
+            f"{' or '.join(wait.success)}; it fails on {', '.join(wait.failure) or 'nothing'}."
+        )
+        paragraphs.append(
+            (
+                text,
+                False,
+            )
+        )
+    if op.verdict is not None:
+        paragraphs.append(
+            (f"Exits 9 (not_ready) when {op.verdict.field.lstrip('/')} is {' or '.join(op.verdict.not_ready)}.", False)
+        )
+    examples = [e for e in op.examples if variant is None or variant in positional_words(e)]
+    if examples:
+        paragraphs.append(("Examples:\n" + "\n".join(f"  {e}" for e in examples), True))
+    return paragraphs
+
+
+def positional_words(example: str) -> list[str]:
+    """The words of an example after ``databay <noun> <verb>`` that are neither a flag nor a flag's value."""
+    import shlex  # noqa: PLC0415
+
+    words = shlex.split(example)[3:]
+    found: list[str] = []
+    index = 0
+    while index < len(words):
+        word = words[index]
+        if not word.startswith("--"):
+            found.append(word)
+            index += 1
+            continue
+        following = words[index + 1] if index + 1 < len(words) else None
+        index += 1 if following is None or following.startswith("--") else 2
+    return found
+
+
+def click_help(op: Operation, variant: str | None = None) -> str:
+    # ``\b`` keeps click from rewrapping a paragraph's lines.
+    return "\n\n".join(f"\b\n{text}" if pre else text for text, pre in help_paragraphs(op, variant))
+
+
+def _usage(op: Operation, flags: list[Flag], variant: str | None) -> str:
+    words = [op.command] + ([variant] if variant else [])
+    words += [flag.name if flag.required else f"[{flag.name}]" for flag in flags if flag.role == "argument"]
+    words.append("[OPTIONS]")
+    return " ".join(words)
+
+
+def _flag_cell(flag: Flag) -> str:
+    if flag.takes == "argument":
+        return f"`{flag.name}`"
+    if flag.takes == "bool":
+        return f"`{flag.name}` / `--no-{flag.name.removeprefix('--')}`"
+    if flag.takes == "switch":
+        return f"`{flag.name}`"
+    metavar = flag.metavar or (flag.param.kind.upper() if flag.param else "TEXT")
+    suffix = " (repeat)" if flag.takes == "multiple" else ""
+    return f"`{flag.name} {metavar}`{suffix}"
+
+
+def _cell(text: str) -> str:
+    return text.replace("|", "\\|").replace("\n", " ")
+
+
+def _command_section(op: Operation, variant: str | None) -> list[str]:
+    title = f"{op.command} {variant}" if variant else op.command
+    lines = [f"### {title}", ""]
+    for text, pre in help_paragraphs(op, variant):
+        lines += (["```", text, "```"] if pre else [text]) + [""]
+    flags = command_flags(op, variant)
+    lines += [f"Usage: `{_usage(op, flags, variant)}`", "", "| Argument or flag | Required | Description |"]
+    lines.append("|---|---|---|")
+    for flag in flags:
+        text = flag.help
+        if flag.choices:
+            text = (f"{text.rstrip('.')}. " if text else "") + f"One of: {', '.join(flag.choices)}."
+        required = "yes" if flag.required else ""
+        lines.append(f"| {_flag_cell(flag)} | {required} | {_cell(text)} |")
+    lines.append("")
+    return lines
+
+
+def commands_markdown(
+    operations: Iterable[Operation], curated: dict[str, str], handwritten: dict[str, tuple[str, str, str]]
+) -> str:
+    """
+    ``commands.md``: every generated command, the operations a hand-written command replaces, then those commands.
+
+    ``curated`` maps an operation id to the hand-written command that replaces it; ``handwritten``
+    holds the hand-written commands this CLI has, so one it lacks is listed as not available.
+    """
+    available = set(handwritten)
+    by_noun: dict[str, list[Operation]] = {}
+    for op in operations:
+        by_noun.setdefault(op.noun, []).append(op)
+    lines = ["# databay commands", "", GENERATED_NOTE, ""]
+    lines += ["Every command also takes the flags `--output`, `--profile`, `--verbose` and `--no-retry`.", ""]
+    replaced: list[tuple[Operation, str]] = []
+    for noun in sorted(by_noun):
+        generated = [op for op in sorted(by_noun[noun], key=lambda o: o.verb) if op.operation_id not in curated]
+        replaced += [(op, curated[op.operation_id]) for op in by_noun[noun] if op.operation_id in curated]
+        if not generated:
+            continue
+        lines += [f"## {noun}", ""]
+        for op in generated:
+            if op.body is not None and op.body.discriminator is not None:
+                for key, _, _ in op.body.variants:
+                    lines += _command_section(op, key)
+            else:
+                lines += _command_section(op, None)
+    if replaced:
+        lines += ["## Operations with a hand-written command", "", "| Operation | Command |", "|---|---|"]
+        for op, command in replaced:
+            status = "" if command.split()[0] in available else " (not in this CLI version)"
+            lines.append(f"| `{op.method.upper()} {op.path}` | `databay {command}`{status} |")
+        lines.append("")
+    lines += ["## Hand-written commands", "", "`databay <command> --help` lists the flags of each.", ""]
+    lines += ["| Command | What it does |", "|---|---|"]
+    lines += [f"| `databay {name}` | {_cell(entry[2])} |" for name, entry in sorted(handwritten.items())]
+    lines.append("")
+    return "\n".join(lines)
+
+
+def errors_markdown(server_codes: dict[str, dict[str, Any]], pipe_codes: dict[str, dict[str, Any]]) -> str:
+    """``errors.md``: the exit codes, the client's own codes, the server's codes and the pipe failure codes."""
+    lines = ["# databay errors", "", GENERATED_NOTE, ""]
+    lines += [
+        "When output is captured, a failed command prints one JSON object on stderr:",
+        '`{"error": {"code", "message", "hint", "next", "recovery", "context", ...}}`.',
+        "Read `recovery.action` first; the exit code is the coarse class.",
+        "",
+        "## Exit codes",
+        "",
+        "| Exit | Meaning |",
+        "|---|---|",
+    ]
+    lines += [f"| {code} | {_cell(text)} |" for code, text in EXIT_CODES.items()]
+    lines += ["", "## Client codes", "", "| Code | Exit | Action | Side effects | Hint |", "|---|---|---|---|---|"]
+    for code, local in sorted(LOCAL_CODES.items()):
+        hint = server_codes[code]["hint"] if local.server_code else local.hint
+        lines.append(f"| `{code}` | {local.exit_code} | {local.action} | {local.side_effects} | {_cell(hint)} |")
+    lines += [
+        "",
+        "## Server codes",
+        "",
+        "| Code | Exit | Action | Side effects | Max retries | Hint |",
+        "|---|---|---|---|---|---|",
+    ]
+    for code, info in sorted(server_codes.items()):
+        exit_code = LOCAL_CODES[code].exit_code if code in LOCAL_CODES else server_exit(code, info["action"])
+        lines.append(
+            f"| `{code}` | {exit_code} | {info['action']} | {info['side_effects']} | {_retries(info['max_retries'])} "
+            f"| {_cell(info['hint'])} |"
+        )
+    lines += [
+        "",
+        "## Pipe failure codes",
+        "",
+        "A pipe that fails records one of these in `error_code`; a wait that ends on the failure reports it.",
+        "",
+        "| Code | Action | Side effects | Max retries | Hint |",
+        "|---|---|---|---|---|",
+    ]
+    for code, info in sorted(pipe_codes.items()):
+        retries = _retries(info["max_retries"])
+        lines.append(f"| `{code}` | {info['action']} | {info['side_effects']} | {retries} | {_cell(info['hint'])} |")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def _retries(value: int | None) -> str:
+    return "" if value is None else str(value)

databay/resource.py

@@ -0,0 +1,167 @@
+"""
+What every generated SDK resource (``databay.resources.<noun>``) does with a method call.
+
+A method passes its arguments by wire name; an argument left at ``UNSET`` is not sent, so the
+server's own default applies. A ``SecretStr`` is revealed only into the request body, and a
+generated model is sent as its JSON.
+"""
+
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Self
+
+from databay import waits
+from databay.errors import DatabayError, DatabayUsageError
+from databay.invoke import CallValues, resolve_project, validate
+
+if TYPE_CHECKING:
+    from databay.invoke import Session
+    from databay.operation import Operation
+    from databay.waits import WaitOutcome
+
+
+class Unset:
+    """The value of an argument the caller did not pass."""
+
+    _instance: Unset | None = None
+
+    def __new__(cls) -> Self:
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance  # type: ignore[return-value]
+
+    def __repr__(self) -> str:
+        return "UNSET"
+
+    def __bool__(self) -> bool:
+        return False
+
+
+UNSET = Unset()
+
+
+@dataclass(slots=True)
+class Waited[T]:
+    """An answer and the wait that followed it."""
+
+    result: T
+    wait: WaitOutcome
+
+
+def wire_value(value: Any) -> Any:  # noqa: ANN401 — any argument
+    """An argument as JSON: a model as its fields, a ``SecretStr`` revealed, lists and dicts element-wise."""
+    from pydantic import BaseModel, SecretStr  # noqa: PLC0415
+
+    if isinstance(value, SecretStr):
+        return value.get_secret_value()
+    if isinstance(value, BaseModel):
+        return value.model_dump(mode="json", by_alias=True, exclude_unset=True)
+    if isinstance(value, list | tuple):
+        return [wire_value(item) for item in value]
+    if isinstance(value, dict):
+        return {key: wire_value(item) for key, item in value.items()}
+    return value
+
+
+def _variant_body(op: Operation, body: Any) -> dict[str, Any]:  # noqa: ANN401
+    assert op.body is not None
+    assert op.body.discriminator is not None
+    discriminator = op.body.discriminator
+    data = wire_value(body)
+    from pydantic import BaseModel  # noqa: PLC0415
+
+    if isinstance(body, BaseModel):
+        data[discriminator] = wire_value(getattr(body, discriminator))
+    keys = [key for key, _, _ in op.body.variants]
+    if not isinstance(data, dict) or data.get(discriminator) not in keys:
+        holder = op.body.variant_field or "body"
+        raise DatabayUsageError(f"`{op.command}` needs a {holder} whose {discriminator} is one of {keys}")
+    return data
+
+
+def call_values(
+    op: Operation,
+    args: dict[str, Any],
+    *,
+    project: str | None,
+    idempotency_key: str | None,
+    body: Any = UNSET,  # noqa: ANN401 — a variant model or its dict: the whole body, or its ``variant_field``
+) -> CallValues:
+    """The ``CallValues`` of an SDK call: each argument placed where its operation takes it."""
+    values = CallValues(project_flag=project, idempotency_key=idempotency_key)
+    project_name = op.project_location[1] if op.project_location else None
+    for param in op.params:
+        value = args.get(param.name, UNSET)
+        if value is UNSET or value is None:
+            continue
+        if param.name == project_name:
+            values.project_explicit = str(value)
+            continue
+        target = {"path": values.path, "query": values.query, "header": values.headers}[param.location]
+        target[param.name] = wire_value(value)
+    if op.body is None:
+        return values
+    if op.body.discriminator is not None and op.body.variant_field is None:
+        values.body = _variant_body(op, body)
+        values.has_body = True
+        return values
+    payload: dict[str, Any] = {}
+    for param in op.body.fields:
+        value = args.get(param.name, UNSET)
+        if value is UNSET:
+            continue
+        if param.name == project_name and value is not None:
+            values.project_explicit = str(value)
+            continue
+        payload[param.name] = wire_value(value)
+    if op.body.variant_field is not None:
+        payload[op.body.variant_field] = _variant_body(op, body)
+    values.body = payload
+    values.has_body = True
+    return values
+
+
+class Resource:
+    """One noun's operations on a ``Session``; the generated subclasses add one method per verb."""
+
+    def __init__(self, session: Session) -> None:
+        self._session = session
+
+    def _call(
+        self,
+        op: Operation,
+        args: dict[str, Any],
+        *,
+        project: str | None = None,
+        idempotency_key: str | None = None,
+        body: Any = UNSET,  # noqa: ANN401
+        wait: bool = False,
+        timeout: float | None = None,
+    ) -> Any:  # noqa: ANN401 — the operation's model, or a Waited of it
+        if op.idempotent and idempotency_key is None:
+            # One key per call, so this call's own retries never create twice.
+            idempotency_key = str(uuid.uuid4())
+        values = call_values(op, args, project=project, idempotency_key=idempotency_key, body=body)
+        if wait and op.resumes is not None:
+            project = resolve_project(op, values, self._session.active_project)
+            self._session.ensure_compatible(op)
+            bound = {**values.path, **values.query}
+            outcome = waits.run(self._session, op.resumes, bound, timeout_s=timeout, project=project)
+            return Waited(validate(op, outcome.status, op.response.model), outcome)
+        result = self._session.call(op, values)
+        if not wait:
+            return result.parsed
+        if op.wait is None:
+            raise DatabayUsageError(f"`{op.command}` has nothing to wait for")
+        bound = waits.bind(op.wait, result.raw, result.path)
+        if bound is None:
+            return Waited(result.parsed, waits.not_started(op.wait))
+        try:
+            outcome = waits.run(self._session, op.wait, bound, timeout_s=timeout, project=result.project)
+        except DatabayError as exc:
+            # The operation itself succeeded: the caller keeps its answer to resume or report.
+            exc.result = result.parsed
+            raise
+        return Waited(result.parsed, outcome)

databay/resources/alerting_webhook.py

@@ -0,0 +1,84 @@
+"""``client.alerting_webhook``: the ``alerting-webhook`` operations.
+
+Generated by python/tools/gen_client.py from contract/core.json; do not edit.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from databay.operations import alerting_webhook as _ops
+from databay.resource import Resource, UNSET, Unset
+
+if TYPE_CHECKING:
+    from pydantic import SecretStr
+
+    from databay.models.alerting_webhook import AlertingWebhookListResponse, AlertingWebhookResponse
+
+
+class AlertingWebhookResource(Resource):
+
+    def create(
+        self,
+        *,
+        name: str,
+        type: str,
+        url: SecretStr | str,
+        scope: str | None | Unset = UNSET,
+        tags: list[str] | None | Unset = UNSET,
+        project: str | None = None,
+        idempotency_key: str | None = None,
+    ) -> AlertingWebhookResponse:
+        """Create Alerting Webhook. ``databay alerting-webhook create``."""
+        return self._call(_ops.ALERTING_WEBHOOK_CREATE, {'name': name, 'scope': scope, 'tags': tags, 'type': type, 'url': url}, project=project, idempotency_key=idempotency_key)
+
+    def delete(
+        self,
+        *,
+        webhook_uuid: str,
+        project: str | None = None,
+    ) -> None:
+        """Delete Alerting Webhook. ``databay alerting-webhook delete``."""
+        return self._call(_ops.ALERTING_WEBHOOK_DELETE, {'webhook_uuid': webhook_uuid}, project=project)
+
+    def get(
+        self,
+        *,
+        webhook_uuid: str,
+        project: str | None = None,
+    ) -> AlertingWebhookResponse:
+        """Get Alerting Webhook. ``databay alerting-webhook get``."""
+        return self._call(_ops.ALERTING_WEBHOOK_GET, {'webhook_uuid': webhook_uuid}, project=project)
+
+    def list(
+        self,
+        *,
+        project: str | None = None,
+    ) -> AlertingWebhookListResponse:
+        """Get Alerting Webhooks. ``databay alerting-webhook list``."""
+        return self._call(_ops.ALERTING_WEBHOOK_LIST, {}, project=project)
+
+    def notify(
+        self,
+        *,
+        body: str,
+        title: str,
+        tags: list[str] | Unset = UNSET,
+        project: str | None = None,
+    ) -> None:
+        """Notify. ``databay alerting-webhook notify``."""
+        return self._call(_ops.ALERTING_WEBHOOK_NOTIFY, {'tags': tags, 'body': body, 'title': title}, project=project)
+
+    def update(
+        self,
+        *,
+        webhook_uuid: str,
+        name: str,
+        type: str,
+        url: SecretStr | str,
+        scope: str | None | Unset = UNSET,
+        tags: list[str] | None | Unset = UNSET,
+        project: str | None = None,
+    ) -> AlertingWebhookResponse:
+        """Update Alerting Webhook. ``databay alerting-webhook update``."""
+        return self._call(_ops.ALERTING_WEBHOOK_UPDATE, {'webhook_uuid': webhook_uuid, 'name': name, 'scope': scope, 'tags': tags, 'type': type, 'url': url}, project=project)