merge main into stream-alerts-empty test branch; resolve conflicts

Same pyproject/test/uv.lock resolution as the parent async-streaming branch.
Note: this branch shares the test/0db470 head with PR #42 (based on the
async-streaming branch) and carries the same standalone-failing test_otel.py;
the OTel client wiring lands in PR #40.

Author: KhaledSalhab-Develeap

pyproject.toml

@@ -23,17 +23,18 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
     "Topic :: Internet :: WWW/HTTP",
     "Typing :: Typed",
+    "Environment :: Console",
 ]
 dependencies = [
     "httpx2>=2.4,<3.0",
     "pydantic>=2.0,<3.0",
 ]
 
 [project.optional-dependencies]
+cli = ["typer[all]>=0.12,<1.0"]
 otel = [
     "opentelemetry-api>=1.20",
 ]
-
 dev = [
     "pytest>=9.0.3",
     "pytest-cov",
@@ -42,10 +43,14 @@ dev = [
     "mypy>=1.10",
     "pydantic",
     "pip-audit>=2.7",
+    "typer[all]>=0.12,<1.0",
     "opentelemetry-api>=1.20",
     "opentelemetry-sdk>=1.20",
 ]
 
+[project.scripts]
+hyp = "hyperping.cli._app:app"
+
 [project.urls]
 Homepage      = "https://github.com/develeap/hyperping-python"
 Documentation = "https://github.com/develeap/hyperping-python#readme"

src/hyperping/__init__.py

@@ -46,6 +46,7 @@
     AlertType,
     DnsRecordType,
     EscalationPolicy,
+    EscalationStep,
     Healthcheck,
     HealthcheckCreate,
     HealthcheckUpdate,
@@ -173,6 +174,7 @@
     "ProbeLogResponse",
     # On-call
     "OnCallSchedule",
+    "EscalationStep",
     "EscalationPolicy",
     "TeamMember",
     # Integrations

src/hyperping/_async_mcp_client.py

@@ -21,7 +21,7 @@
 from hyperping._async_mcp_transport import AsyncMcpTransport
 from hyperping.endpoints import MCP_URL
 from hyperping.models._integration_models import Integration
-from hyperping.models._monitor_models import Monitor
+from hyperping.models._monitor_models import Monitor, MonitorCreate
 from hyperping.models._observability_models import MonitorAnomaly, ProbeLogResponse
 from hyperping.models._oncall_models import EscalationPolicy, OnCallSchedule, TeamMember
 from hyperping.models._outage_models import OutageTimeline
@@ -270,3 +270,52 @@ async def search_monitors_by_name(self, query: str) -> list[Monitor]:
         data = await self._call("search_monitors_by_name", {"query": query})
         raw = data if isinstance(data, list) else []
         return [Monitor.model_validate(m) for m in raw]
+
+    async def create_monitor(self, monitor: MonitorCreate) -> Monitor:
+        """Create a new monitor.
+
+        Args:
+            monitor: Monitor configuration.
+        """
+        return Monitor.model_validate(
+            await self._call("create_monitor", monitor.model_dump(exclude_none=True))
+        )
+
+    async def update_monitor(self, monitor_uuid: str, **kwargs: Any) -> Monitor:
+        """Update an existing monitor.
+
+        Args:
+            monitor_uuid: Monitor UUID.
+            **kwargs: Fields to update.
+        """
+        return Monitor.model_validate(
+            await self._call("update_monitor", {"uuid": monitor_uuid, **kwargs})
+        )
+
+    async def pause_monitor(self, monitor_uuid: str) -> Monitor:
+        """Pause a monitor.
+
+        Args:
+            monitor_uuid: Monitor UUID.
+        """
+        return Monitor.model_validate(
+            await self._call("pause_monitor", {"uuid": monitor_uuid})
+        )
+
+    async def resume_monitor(self, monitor_uuid: str) -> Monitor:
+        """Resume a paused monitor.
+
+        Args:
+            monitor_uuid: Monitor UUID.
+        """
+        return Monitor.model_validate(
+            await self._call("resume_monitor", {"uuid": monitor_uuid})
+        )
+
+    async def delete_monitor(self, monitor_uuid: str) -> None:
+        """Delete a monitor.
+
+        Args:
+            monitor_uuid: Monitor UUID.
+        """
+        await self._call("delete_monitor", {"uuid": monitor_uuid})

src/hyperping/cli/__init__.py

@@ -0,0 +1,52 @@
+"""Main hyp CLI application."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from hyperping._version import __version__
+from hyperping.cli._incidents import incident_app
+from hyperping.cli._monitors import monitor_app
+from hyperping.cli._statuspages import statuspage_app
+from hyperping.cli._tenant import tenant_app
+
+app = typer.Typer(
+    name="hyp",
+    help="Hyperping CLI: manage monitors, incidents, and status pages.",
+    no_args_is_help=True,
+)
+
+app.add_typer(monitor_app, name="monitor")
+app.add_typer(incident_app, name="incident")
+app.add_typer(statuspage_app, name="statuspage")
+app.add_typer(tenant_app, name="tenant")
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"hyp {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    api_key: Annotated[
+        str | None,
+        typer.Option("--api-key", envvar="HYPERPING_API_KEY", help="Hyperping API key."),
+    ] = None,
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Output as JSON."),
+    ] = False,
+    version: Annotated[
+        bool | None,
+        typer.Option("--version", callback=_version_callback, is_eager=True, help="Show version."),
+    ] = None,
+) -> None:
+    """Hyperping CLI."""
+    ctx.ensure_object(dict)
+    ctx.obj["api_key"] = api_key
+    ctx.obj["json"] = json_output

src/hyperping/cli/_app.py

@@ -0,0 +1,24 @@
+"""CLI client factory and API key resolution."""
+
+from __future__ import annotations
+
+import os
+
+import typer
+
+from hyperping.client import HyperpingClient
+
+
+def get_client(api_key: str | None) -> HyperpingClient:
+    """Resolve API key and return a configured client.
+
+    Resolution order: explicit flag value, then HYPERPING_API_KEY env var.
+    Raises typer.BadParameter if no key is available.
+    """
+    key = api_key or os.environ.get("HYPERPING_API_KEY")
+    if not key:
+        raise typer.BadParameter(
+            "API key required. Pass --api-key or set HYPERPING_API_KEY.",
+            param_hint="--api-key",
+        )
+    return HyperpingClient(api_key=key)

src/hyperping/cli/_config.py

@@ -0,0 +1,87 @@
+"""hyp incident subcommands."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from hyperping.cli._config import get_client
+from hyperping.cli._output import print_detail, print_error, print_success, print_table
+from hyperping.exceptions import HyperpingAPIError
+from hyperping.models import Incident, IncidentCreate, IncidentType, LocalizedText
+
+incident_app = typer.Typer(name="incident", help="Manage incidents.")
+
+
+def _incident_row(i: Incident) -> list[object]:
+    return [i.uuid, i.title_en, i.type, str(i.is_resolved), i.date or ""]
+
+
+@incident_app.command("list")
+def incident_list(
+    ctx: typer.Context,
+    status: Annotated[str | None, typer.Option("--status", help="Filter by status")] = None,
+) -> None:
+    """List incidents."""
+    api_key: str | None = ctx.obj.get("api_key")
+    json_mode: bool = ctx.obj.get("json", False)
+    client = get_client(api_key)
+    incidents = client.list_incidents(status=status)
+    columns = ["uuid", "title", "type", "resolved", "date"]
+    rows = [_incident_row(i) for i in incidents]
+    print_table("Incidents", columns, rows, json_mode)
+
+
+@incident_app.command("create")
+def incident_create(
+    ctx: typer.Context,
+    title: Annotated[str, typer.Option("--title", help="Incident title (English)")],
+    text: Annotated[str, typer.Option("--text", help="Incident message (English)")],
+    statuspage: Annotated[str, typer.Option("--statuspage", help="Status page UUID")],
+    incident_type: Annotated[
+        str | None, typer.Option("--type", help="Incident type: incident or outage")
+    ] = None,
+) -> None:
+    """Create a new incident."""
+    api_key: str | None = ctx.obj.get("api_key")
+    json_mode: bool = ctx.obj.get("json", False)
+    client = get_client(api_key)
+    payload = IncidentCreate(
+        title=LocalizedText.from_string(title),
+        text=LocalizedText.from_string(text),
+        type=IncidentType(incident_type) if incident_type else IncidentType.INCIDENT,
+        statuspages=[statuspage],
+    )
+    try:
+        incident = client.create_incident(payload)
+    except HyperpingAPIError as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1) from exc
+    fields = {
+        "uuid": incident.uuid,
+        "title": incident.title_en,
+        "type": incident.type,
+        "resolved": incident.is_resolved,
+        "date": incident.date or "",
+    }
+    print_detail("Incident", fields, json_mode)
+
+
+@incident_app.command("resolve")
+def incident_resolve(
+    ctx: typer.Context,
+    incident_id: Annotated[str, typer.Argument(help="Incident UUID")],
+    message: Annotated[
+        str | None, typer.Option("--message", help="Resolution message")
+    ] = None,
+) -> None:
+    """Resolve an incident."""
+    api_key: str | None = ctx.obj.get("api_key")
+    client = get_client(api_key)
+    try:
+        incident = client.resolve_incident(incident_id, message=message)
+    except HyperpingAPIError as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1) from exc
+    print_success(f"Incident {incident.uuid} resolved.")

src/hyperping/cli/_incidents.py

@@ -0,0 +1,90 @@
+"""hyp monitor subcommands."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from hyperping.cli._config import get_client
+from hyperping.cli._output import print_detail, print_error, print_success, print_table
+from hyperping.exceptions import HyperpingAPIError
+from hyperping.models import Monitor
+
+monitor_app = typer.Typer(name="monitor", help="Manage monitors.")
+
+
+def _monitor_status(m: Monitor) -> str:
+    if m.paused:
+        return "paused"
+    return "down" if m.down else "up"
+
+
+@monitor_app.command("list")
+def monitor_list(ctx: typer.Context) -> None:
+    """List all monitors."""
+    api_key: str | None = ctx.obj.get("api_key")
+    json_mode: bool = ctx.obj.get("json", False)
+    client = get_client(api_key)
+    monitors = client.list_monitors()
+    columns = ["uuid", "name", "url", "protocol", "status"]
+    rows = [[m.uuid, m.name, m.url, m.protocol, _monitor_status(m)] for m in monitors]
+    print_table("Monitors", columns, rows, json_mode)
+
+
+@monitor_app.command("get")
+def monitor_get(
+    ctx: typer.Context,
+    monitor_id: Annotated[str, typer.Argument(help="Monitor UUID")],
+) -> None:
+    """Show a single monitor."""
+    api_key: str | None = ctx.obj.get("api_key")
+    json_mode: bool = ctx.obj.get("json", False)
+    client = get_client(api_key)
+    try:
+        m = client.get_monitor(monitor_id)
+    except HyperpingAPIError as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1) from exc
+    fields = {
+        "uuid": m.uuid,
+        "name": m.name,
+        "url": m.url,
+        "protocol": m.protocol,
+        "status": _monitor_status(m),
+        "check_frequency": m.check_frequency,
+        "regions": ", ".join(m.regions),
+    }
+    print_detail("Monitor", fields, json_mode)
+
+
+@monitor_app.command("pause")
+def monitor_pause(
+    ctx: typer.Context,
+    monitor_id: Annotated[str, typer.Argument(help="Monitor UUID")],
+) -> None:
+    """Pause a monitor."""
+    api_key: str | None = ctx.obj.get("api_key")
+    client = get_client(api_key)
+    try:
+        m = client.pause_monitor(monitor_id)
+    except HyperpingAPIError as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1) from exc
+    print_success(f"Monitor {m.uuid} paused (status: {_monitor_status(m)})")
+
+
+@monitor_app.command("resume")
+def monitor_resume(
+    ctx: typer.Context,
+    monitor_id: Annotated[str, typer.Argument(help="Monitor UUID")],
+) -> None:
+    """Resume a paused monitor."""
+    api_key: str | None = ctx.obj.get("api_key")
+    client = get_client(api_key)
+    try:
+        m = client.resume_monitor(monitor_id)
+    except HyperpingAPIError as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1) from exc
+    print_success(f"Monitor {m.uuid} resumed (status: {_monitor_status(m)})")