hyperping 1.3.0__tar.gz → 1.4.0__tar.gz

{hyperping-1.3.0 → hyperping-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperping
-Version: 1.3.0
+Version: 1.4.0
 Summary: Python SDK for the Hyperping uptime monitoring and incident management API
 Project-URL: Homepage, https://github.com/develeap/hyperping-python
 Project-URL: Documentation, https://github.com/develeap/hyperping-python#readme

{hyperping-1.3.0 → hyperping-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hyperping"
-version = "1.3.0"
+version = "1.4.0"
 description = "Python SDK for the Hyperping uptime monitoring and incident management API"
 readme = {file = "README.md", content-type = "text/markdown"}
 license = {text = "MIT"}

hyperping-1.4.0/scripts/verify_endpoints.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""Verify speculative MCP-discovered endpoint paths against the live Hyperping API.
+
+Usage:
+    export HYPERPING_API_KEY=sk_...
+    python scripts/verify_endpoints.py
+
+All calls are read-only (GET only). Safe to run repeatedly.
+"""
+
+import os
+import sys
+from dataclasses import dataclass
+
+import httpx
+
+API_BASE = "https://api.hyperping.io"
+
+
+@dataclass
+class Result:
+    method: str
+    path: str
+    status: int
+    ok: bool
+    snippet: str
+
+
+def probe(
+    client: httpx.Client,
+    method_name: str,
+    path: str,
+    params: dict | None = None,
+) -> Result:
+    """Send a GET request and return a Result."""
+    url = f"{API_BASE}{path}"
+    try:
+        resp = client.get(url, params=params or {})
+        body = resp.text[:120].replace("\n", " ")
+        return Result(
+            method=method_name,
+            path=path,
+            status=resp.status_code,
+            ok=resp.status_code < 400,
+            snippet=body,
+        )
+    except httpx.HTTPError as exc:
+        return Result(
+            method=method_name,
+            path=path,
+            status=0,
+            ok=False,
+            snippet=f"Connection error: {exc}",
+        )
+
+
+def main() -> int:
+    api_key = os.environ.get("HYPERPING_API_KEY", "")
+    if not api_key:
+        print("ERROR: Set HYPERPING_API_KEY environment variable.")
+        return 1
+
+    headers = {"Authorization": f"Bearer {api_key}"}
+    client = httpx.Client(headers=headers, timeout=15.0)
+
+    # -- Fetch real UUIDs for sub-resource endpoints --
+    print("Fetching monitor and outage UUIDs for sub-resource tests...")
+    monitor_uuid: str | None = None
+    outage_uuid: str | None = None
+
+    resp = client.get(f"{API_BASE}/v1/monitors")
+    if resp.status_code == 200:
+        data = resp.json()
+        monitors = data if isinstance(data, list) else data.get("monitors", [])
+        if monitors:
+            monitor_uuid = monitors[0].get("uuid") or monitors[0].get("id")
+            print(f"  Monitor UUID: {monitor_uuid}")
+
+    resp = client.get(f"{API_BASE}/v2/outages")
+    if resp.status_code == 200:
+        data = resp.json()
+        outages = data if isinstance(data, list) else data.get("outages", [])
+        if outages:
+            outage_uuid = outages[0].get("uuid") or outages[0].get("id")
+            print(f"  Outage UUID:  {outage_uuid}")
+
+    print()
+
+    # -- Define all speculative endpoints to verify --
+    checks: list[tuple[str, str, dict | None]] = [
+        # Endpoint enum speculative paths
+        ("get_status_summary", "/v2/status-summary", None),
+        ("list_recent_alerts", "/v2/alerts", None),
+        ("list_on_call_schedules", "/v2/on-call-schedules", None),
+        ("list_escalation_policies", "/v2/escalation-policies", None),
+        ("list_team_members", "/v2/team-members", None),
+        ("list_integrations", "/v2/integrations", None),
+        # Monitor search
+        ("search_monitors", "/v1/monitors/search", {"query": "test"}),
+    ]
+
+    # Sub-resource paths needing a real UUID
+    if monitor_uuid:
+        checks.extend([
+            (
+                "get_monitor_response_time",
+                f"/v2/reporting/response-time/{monitor_uuid}",
+                {"period": "24h"},
+            ),
+            (
+                "get_monitor_mtta",
+                f"/v2/reporting/mtta/{monitor_uuid}",
+                {"period": "30d"},
+            ),
+            (
+                "get_monitor_anomalies",
+                f"/v1/monitors/{monitor_uuid}/anomalies",
+                None,
+            ),
+            (
+                "get_monitor_http_logs",
+                f"/v1/monitors/{monitor_uuid}/http-logs",
+                {"page": "0", "limit": "5"},
+            ),
+        ])
+    else:
+        print("WARNING: No monitors found; skipping monitor sub-resource checks.\n")
+
+    if outage_uuid:
+        checks.append((
+            "get_outage_timeline",
+            f"/v2/outages/{outage_uuid}/timeline",
+            None,
+        ))
+    else:
+        print("WARNING: No outages found; skipping outage sub-resource checks.\n")
+
+    # -- Run probes --
+    results: list[Result] = []
+    for method_name, path, params in checks:
+        r = probe(client, method_name, path, params)
+        results.append(r)
+
+    client.close()
+
+    # -- Print results table --
+    print(f"{'Method':<30} {'Path':<50} {'Status':<8} {'Result'}")
+    print("-" * 120)
+    for r in results:
+        tag = "OK" if r.ok else ("404" if r.status == 404 else "ERROR")
+        print(f"{r.method:<30} {r.path:<50} {r.status:<8} {tag}")
+        if not r.ok:
+            print(f"  {r.snippet}")
+
+    # -- Summary --
+    ok_count = sum(1 for r in results if r.ok)
+    fail_count = sum(1 for r in results if not r.ok)
+    not_found = sum(1 for r in results if r.status == 404)
+    print()
+    print(f"Total: {len(results)} | OK: {ok_count} | 404: {not_found} | Other errors: {fail_count - not_found}")
+
+    return 1 if fail_count > 0 else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{hyperping-1.3.0 → hyperping-1.4.0}/src/hyperping/__init__.py

@@ -15,6 +15,7 @@ Quick start::
 """
 
 from hyperping._async_client import AsyncHyperpingClient
+from hyperping._mcp_transport import MCP_URL
 from hyperping._version import __version__
 from hyperping.client import (
     CircuitBreaker,
@@ -35,6 +36,7 @@ from hyperping.exceptions import (
     HyperpingRateLimitError,
     HyperpingValidationError,
 )
+from hyperping.mcp_client import HyperpingMcpClient
 from hyperping.models import (
     DEFAULT_REGIONS,
     AddIncidentUpdateRequest,
@@ -91,6 +93,9 @@ __all__ = [
     # Clients
     "AsyncHyperpingClient",
     "HyperpingClient",
+    "HyperpingMcpClient",
+    # MCP
+    "MCP_URL",
     # Configuration
     "RetryConfig",
     "CircuitBreakerConfig",

{hyperping-1.3.0 → hyperping-1.4.0}/src/hyperping/_async_client.py

@@ -21,13 +21,9 @@ from pydantic import SecretStr
 
 from hyperping._async_healthchecks_mixin import AsyncHealthchecksMixin
 from hyperping._async_incidents_mixin import AsyncIncidentsMixin
-from hyperping._async_integrations_mixin import AsyncIntegrationsMixin
 from hyperping._async_maintenance_mixin import AsyncMaintenanceMixin
 from hyperping._async_monitors_mixin import AsyncMonitorsMixin
-from hyperping._async_observability_mixin import AsyncObservabilityMixin
-from hyperping._async_oncall_mixin import AsyncOnCallMixin
 from hyperping._async_outages_mixin import AsyncOutagesMixin
-from hyperping._async_reporting_mixin import AsyncReportingMixin
 from hyperping._async_statuspages_mixin import AsyncStatusPagesMixin
 from hyperping._circuit_breaker import (
     CircuitBreaker,
@@ -52,10 +48,6 @@ class AsyncHyperpingClient(
     AsyncOutagesMixin,
     AsyncStatusPagesMixin,
     AsyncHealthchecksMixin,
-    AsyncReportingMixin,
-    AsyncObservabilityMixin,
-    AsyncOnCallMixin,
-    AsyncIntegrationsMixin,
 ):
     """Async client for interacting with the Hyperping API.
 

{hyperping-1.3.0 → hyperping-1.4.0}/src/hyperping/_async_incidents_mixin.py

@@ -45,9 +45,7 @@ class AsyncIncidentsMixin(_AsyncClientProtocol):
         if status:
             params["status"] = status
 
-        response = await self._request(
-            "GET", Endpoint.INCIDENTS, params=params or None
-        )
+        response = await self._request("GET", Endpoint.INCIDENTS, params=params or None)
         return parse_list(unwrap_list(response, "incidents"), Incident, "incident")
 
     async def get_incident(self, incident_id: str) -> Incident:
@@ -114,9 +112,7 @@ class AsyncIncidentsMixin(_AsyncClientProtocol):
         validate_id(incident_id, "incident_id")
         payload = update.model_dump(exclude_none=True, by_alias=True)
         response = expect_dict(
-            await self._request(
-                "PUT", f"{Endpoint.INCIDENTS}/{incident_id}", json=payload
-            ),
+            await self._request("PUT", f"{Endpoint.INCIDENTS}/{incident_id}", json=payload),
             "update_incident",
         )
         return Incident.model_validate(response)
@@ -145,9 +141,7 @@ class AsyncIncidentsMixin(_AsyncClientProtocol):
         await self._request("POST", url, json=payload)
         return await self.get_incident(incident_id)
 
-    async def resolve_incident(
-        self, incident_id: str, message: str | None = None
-    ) -> Incident:
+    async def resolve_incident(self, incident_id: str, message: str | None = None) -> Incident:
         """Resolve an incident.
 
         Args:

{hyperping-1.3.0 → hyperping-1.4.0}/src/hyperping/_async_maintenance_mixin.py

@@ -41,9 +41,7 @@ class AsyncMaintenanceMixin(_AsyncClientProtocol):
         if status:
             params["status"] = status
 
-        response = await self._request(
-            "GET", Endpoint.MAINTENANCE, params=params or None
-        )
+        response = await self._request("GET", Endpoint.MAINTENANCE, params=params or None)
 
         raw = unwrap_list(response, "maintenanceWindows")
         if not raw and isinstance(response, dict) and "maintenance" in response:
@@ -64,9 +62,7 @@ class AsyncMaintenanceMixin(_AsyncClientProtocol):
             HyperpingNotFoundError: If maintenance not found
         """
         validate_id(maintenance_id, "maintenance_id")
-        response = await self._request(
-            "GET", f"{Endpoint.MAINTENANCE}/{maintenance_id}"
-        )
+        response = await self._request("GET", f"{Endpoint.MAINTENANCE}/{maintenance_id}")
         return Maintenance.model_validate(expect_dict(response, "get_maintenance"))
 
     async def create_maintenance(self, maintenance: MaintenanceCreate) -> Maintenance:
@@ -127,9 +123,7 @@ class AsyncMaintenanceMixin(_AsyncClientProtocol):
         payload.update(partial)
 
         response = expect_dict(
-            await self._request(
-                "PUT", f"{Endpoint.MAINTENANCE}/{maintenance_id}", json=payload
-            ),
+            await self._request("PUT", f"{Endpoint.MAINTENANCE}/{maintenance_id}", json=payload),
             "update_maintenance",
         )
         return Maintenance.model_validate(response)

{hyperping-1.3.0 → hyperping-1.4.0}/src/hyperping/_async_monitors_mixin.py

@@ -187,16 +187,3 @@ class AsyncMonitorsMixin(_AsyncClientProtocol):
             if r.uuid == monitor_id:
                 return r
         raise HyperpingNotFoundError(f"No report found for monitor: {monitor_id}")
-
-    async def search_monitors_by_name(self, query: str) -> list[Monitor]:
-        """Search monitors by name (case-insensitive substring match)."""
-        if not query:
-            return []
-        try:
-            result = await self._request(
-                "GET", f"{Endpoint.MONITORS}/search", params={"query": query}
-            )
-        except HyperpingNotFoundError:
-            return []
-        items = result if isinstance(result, list) else []
-        return parse_list(items, Monitor, "monitor")

{hyperping-1.3.0 → hyperping-1.4.0}/src/hyperping/_async_outages_mixin.py

@@ -19,7 +19,6 @@ from hyperping._utils import (
 from hyperping.endpoints import Endpoint
 from hyperping.exceptions import HyperpingNotFoundError
 from hyperping.models import Outage, OutageAction
-from hyperping.models._outage_models import OutageTimeline, OutageTimelineEvent
 
 logger = logging.getLogger(__name__)
 
@@ -206,33 +205,3 @@ class AsyncOutagesMixin(_AsyncClientProtocol):
         validate_id(outage_id, "outage_id")
         result = await self._request("GET", f"{Endpoint.OUTAGES}/{outage_id}")
         return Outage.model_validate(expect_dict(result, "get_outage"))
-
-    async def get_outage_timeline(self, outage_id: str) -> OutageTimeline:
-        """Get the lifecycle timeline for an outage."""
-        validate_id(outage_id, "outage_id")
-        result = await self._request("GET", f"{Endpoint.OUTAGES}/{outage_id}/timeline")
-        data = expect_dict(result, "get_outage_timeline")
-        raw_events = data.get("events", [])
-        events = parse_list(raw_events, OutageTimelineEvent, "timeline_event")
-        return OutageTimeline.model_validate({"outageUuid": outage_id, "events": events})
-
-    async def get_monitor_outages(
-        self,
-        monitor_uuid: str,
-        page: int | None = None,
-        status: str = "all",
-    ) -> list[Outage]:
-        """Get outages scoped to a single monitor."""
-        validate_id(monitor_uuid, "monitor_uuid")
-        params: dict[str, Any] = {
-            "monitor_uuid": monitor_uuid,
-            "status": status,
-        }
-        if page is not None:
-            params["page"] = page
-        try:
-            result = await self._request("GET", Endpoint.OUTAGES, params=params)
-        except HyperpingNotFoundError:
-            return []
-        items = result if isinstance(result, list) else []
-        return parse_list(items, Outage, "outage")

{hyperping-1.3.0 → hyperping-1.4.0}/src/hyperping/_async_statuspages_mixin.py

@@ -69,8 +69,12 @@ class AsyncStatusPagesMixin(_AsyncClientProtocol):
 
         try:
             return await collect_all_pages_async(
-                self._request, Endpoint.STATUSPAGES, "statuspages",
-                params or None, StatusPage, "status page",
+                self._request,
+                Endpoint.STATUSPAGES,
+                "statuspages",
+                params or None,
+                StatusPage,
+                "status page",
             )
         except HyperpingNotFoundError:
             logger.debug("Status pages endpoint not available (404)")
@@ -131,9 +135,7 @@ class AsyncStatusPagesMixin(_AsyncClientProtocol):
         validate_id(status_page_id, "status_page_id")
         payload = update.model_dump(exclude_none=True, by_alias=True)
         response = expect_dict(
-            await self._request(
-                "PUT", f"{Endpoint.STATUSPAGES}/{status_page_id}", json=payload
-            ),
+            await self._request("PUT", f"{Endpoint.STATUSPAGES}/{status_page_id}", json=payload),
             "update_status_page",
         )
         return StatusPage.model_validate(response)
@@ -189,13 +191,15 @@ class AsyncStatusPagesMixin(_AsyncClientProtocol):
             )
 
         return await collect_all_pages_async(
-            self._request, endpoint, "subscribers",
-            params or None, StatusPageSubscriber, "subscriber",
+            self._request,
+            endpoint,
+            "subscribers",
+            params or None,
+            StatusPageSubscriber,
+            "subscriber",
         )
 
-    async def add_subscriber(
-        self, status_page_id: str, email: str
-    ) -> StatusPageSubscriber:
+    async def add_subscriber(self, status_page_id: str, email: str) -> StatusPageSubscriber:
         """Add a subscriber to a status page.
 
         Args:
@@ -225,9 +229,7 @@ class AsyncStatusPagesMixin(_AsyncClientProtocol):
         )
         return StatusPageSubscriber.model_validate(response)
 
-    async def remove_subscriber(
-        self, status_page_id: str, subscriber_id: str
-    ) -> None:
+    async def remove_subscriber(self, status_page_id: str, subscriber_id: str) -> None:
         """Remove a subscriber from a status page.
 
         Args:

{hyperping-1.3.0 → hyperping-1.4.0}/src/hyperping/_incidents_mixin.py

@@ -48,7 +48,9 @@ class IncidentsMixin(_ClientProtocol):
             params["status"] = status
 
         response = self._request(
-            "GET", Endpoint.INCIDENTS, params=params or None  # M20
+            "GET",
+            Endpoint.INCIDENTS,
+            params=params or None,  # M20
         )
         return parse_list(unwrap_list(response, "incidents"), Incident, "incident")
 

{hyperping-1.3.0 → hyperping-1.4.0}/src/hyperping/_internals.py

@@ -28,7 +28,4 @@ def sanitize_for_log(data: dict[str, Any] | None) -> dict[str, Any] | None:
     """
     if data is None:
         return None
-    return {
-        k: "[REDACTED]" if k.lower() in _SENSITIVE_LOG_KEYS else v
-        for k, v in data.items()
-    }
+    return {k: "[REDACTED]" if k.lower() in _SENSITIVE_LOG_KEYS else v for k, v in data.items()}

{hyperping-1.3.0 → hyperping-1.4.0}/src/hyperping/_maintenance_mixin.py

@@ -43,7 +43,9 @@ class MaintenanceMixin(_ClientProtocol):
             params["status"] = status
 
         response = self._request(
-            "GET", Endpoint.MAINTENANCE, params=params or None  # M20
+            "GET",
+            Endpoint.MAINTENANCE,
+            params=params or None,  # M20
         )
 
         # API returns {"maintenanceWindows": [...]} as of current version

hyperping-1.4.0/src/hyperping/_mcp_transport.py

@@ -0,0 +1,145 @@
+"""JSON-RPC 2.0 transport for the Hyperping MCP server."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import httpx
+from pydantic import SecretStr
+
+from hyperping.exceptions import HyperpingAPIError, HyperpingAuthError
+
+MCP_URL = "https://api.hyperping.io/v1/mcp"
+_PROTOCOL_VERSION = "2025-03-26"
+
+
+class McpTransport:
+    """Low-level JSON-RPC 2.0 client for the Hyperping MCP server.
+
+    The MCP server exposes tools not available via the REST API: on-call
+    schedules, anomalies, alerts, integrations, probe logs, and more.
+
+    Uses the same Bearer token API key as the REST client.
+    """
+
+    def __init__(
+        self,
+        api_key: str | SecretStr,
+        base_url: str = MCP_URL,
+        timeout: float = 30.0,
+    ) -> None:
+        token = api_key.get_secret_value() if isinstance(api_key, SecretStr) else api_key
+        self._url = base_url.rstrip("/")
+        self._client = httpx.Client(
+            headers={
+                "Authorization": f"Bearer {token}",
+                "Content-Type": "application/json",
+                "Accept": "application/json, text/event-stream",
+            },
+            timeout=timeout,
+        )
+        self._initialized = False
+        self._request_id = 0
+
+    def _next_id(self) -> int:
+        self._request_id += 1
+        return self._request_id
+
+    def _send_rpc(
+        self,
+        method: str,
+        params: dict[str, Any] | None = None,
+        *,
+        is_notification: bool = False,
+    ) -> dict[str, Any] | None:
+        payload: dict[str, Any] = {"jsonrpc": "2.0", "method": method}
+        if params is not None:
+            payload["params"] = params
+        if not is_notification:
+            payload["id"] = self._next_id()
+
+        resp = self._client.post(self._url, content=json.dumps(payload))
+
+        if resp.status_code == 401:
+            raise HyperpingAuthError("Invalid or expired API key")
+        if resp.status_code == 202:
+            return None  # Notification accepted
+        if resp.status_code != 200:
+            raise HyperpingAPIError(
+                f"MCP server returned HTTP {resp.status_code}",
+                status_code=resp.status_code,
+                response_body={"raw": resp.text[:500]},
+            )
+        if is_notification:
+            return None
+
+        data = resp.json()
+        if "error" in data:
+            err = data["error"]
+            raise HyperpingAPIError(
+                f"MCP error {err.get('code', '?')}: {err.get('message', 'unknown')}",
+                status_code=resp.status_code,
+                response_body=err,
+            )
+        return data  # type: ignore[no-any-return]
+
+    def initialize(self) -> dict[str, Any]:
+        """Perform MCP handshake. Called automatically on first tool call."""
+        result = self._send_rpc(
+            "initialize",
+            {
+                "protocolVersion": _PROTOCOL_VERSION,
+                "capabilities": {},
+                "clientInfo": {"name": "hyperping-python", "version": "1.4.0"},
+            },
+        )
+        self._send_rpc("notifications/initialized", is_notification=True)
+        self._initialized = True
+        return result.get("result", {}) if result else {}
+
+    def call_tool(
+        self,
+        tool_name: str,
+        arguments: dict[str, Any] | None = None,
+    ) -> Any:
+        """Call an MCP tool and return parsed response data.
+
+        Auto-initializes on first call. Extracts and parses the JSON
+        string from ``result.content[0].text``.
+        """
+        if not self._initialized:
+            self.initialize()
+
+        result = self._send_rpc(
+            "tools/call",
+            {"name": tool_name, "arguments": arguments or {}},
+        )
+        if result is None:
+            return None
+
+        content = result.get("result", {}).get("content", [])
+        if not content:
+            return None
+
+        text = content[0].get("text", "")
+        if not text:
+            return None
+
+        try:
+            return json.loads(text)
+        except json.JSONDecodeError as exc:
+            raise HyperpingAPIError(
+                f"Failed to parse MCP tool response: {exc}",
+                status_code=200,
+                response_body={"raw": text[:500]},
+            ) from exc
+
+    def close(self) -> None:
+        self._client.close()
+
+    def __enter__(self) -> McpTransport:
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()

{hyperping-1.3.0 → hyperping-1.4.0}/src/hyperping/_monitors_mixin.py

@@ -213,23 +213,3 @@ class MonitorsMixin(_ClientProtocol):
             if r.uuid == monitor_id:
                 return r
         raise HyperpingNotFoundError(f"No report found for monitor: {monitor_id}")
-
-    def search_monitors_by_name(self, query: str) -> list[Monitor]:
-        """Search monitors by name (case-insensitive substring match).
-
-        Args:
-            query: Search string to match against monitor names and URLs.
-
-        Returns:
-            List of matching :class:`~hyperping.models.Monitor` objects.
-            Returns empty list on 404 or no matches.
-        """
-        if not query:
-            return []
-        try:
-            # Path is speculative; derived from MCP tool name.
-            result = self._request("GET", f"{Endpoint.MONITORS}/search", params={"query": query})
-        except HyperpingNotFoundError:
-            return []
-        items = result if isinstance(result, list) else []
-        return parse_list(items, Monitor, "monitor")