hyperping 1.2.1__tar.gz → 1.4.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperping
-Version: 1.2.1
+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.2.1 → hyperping-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hyperping"
-version = "1.2.1"
+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.2.1 → 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,10 +36,13 @@ from hyperping.exceptions import (
     HyperpingRateLimitError,
     HyperpingValidationError,
 )
+from hyperping.mcp_client import HyperpingMcpClient
 from hyperping.models import (
     DEFAULT_REGIONS,
     AddIncidentUpdateRequest,
+    AlertNotification,
     DnsRecordType,
+    EscalationPolicy,
     Healthcheck,
     HealthcheckCreate,
     HealthcheckUpdate,
@@ -49,11 +53,13 @@ from hyperping.models import (
     IncidentUpdate,
     IncidentUpdateRequest,
     IncidentUpdateType,
+    Integration,
     LocalizedText,
     Maintenance,
     MaintenanceCreate,
     MaintenanceUpdate,
     Monitor,
+    MonitorAnomaly,
     MonitorBase,
     MonitorCreate,
     MonitorFrequency,
@@ -63,10 +69,14 @@ from hyperping.models import (
     MonitorTimeout,
     MonitorUpdate,
     NotificationOption,
+    OnCallSchedule,
     Outage,
     OutageAction,
     OutageDetail,
     OutageStats,
+    OutageTimeline,
+    OutageTimelineEvent,
+    ProbeLog,
     Region,
     ReportPeriod,
     RequestHeader,
@@ -74,6 +84,7 @@ from hyperping.models import (
     StatusPageCreate,
     StatusPageSubscriber,
     StatusPageUpdate,
+    StatusSummary,
 )
 
 __all__ = [
@@ -82,6 +93,9 @@ __all__ = [
     # Clients
     "AsyncHyperpingClient",
     "HyperpingClient",
+    "HyperpingMcpClient",
+    # MCP
+    "MCP_URL",
     # Configuration
     "RetryConfig",
     "CircuitBreakerConfig",
@@ -137,6 +151,19 @@ __all__ = [
     # Outages
     "Outage",
     "OutageAction",
+    "OutageTimeline",
+    "OutageTimelineEvent",
+    # Observability
+    "MonitorAnomaly",
+    "ProbeLog",
+    "AlertNotification",
+    # On-call
+    "OnCallSchedule",
+    "EscalationPolicy",
+    # Integrations
+    "Integration",
+    # Reporting
+    "StatusSummary",
     # Healthchecks
     "Healthcheck",
     "HealthcheckCreate",
@@ -161,8 +188,7 @@ def __getattr__(name: str) -> object:
 
     if name == "HYPERPING_API_BASE":
         warnings.warn(
-            "HYPERPING_API_BASE is deprecated and will be removed in v0.3.0. "
-            "Use API_BASE instead.",
+            "HYPERPING_API_BASE is deprecated and will be removed in v0.3.0. Use API_BASE instead.",
             DeprecationWarning,
             stacklevel=2,
         )
@@ -170,8 +196,7 @@ def __getattr__(name: str) -> object:
 
     if name == "API_PATHS":
         warnings.warn(
-            "API_PATHS is deprecated and will be removed in v0.3.0. "
-            "Use the Endpoint enum instead.",
+            "API_PATHS is deprecated and will be removed in v0.3.0. Use the Endpoint enum instead.",
             DeprecationWarning,
             stacklevel=2,
         )
@@ -199,7 +224,10 @@ def __getattr__(name: str) -> object:
 
     # Symbols removed from __all__ (H5) but still accessible for backward compat
     _endpoint_helpers = {
-        "EndpointConfig", "ENDPOINTS", "get_endpoint_url", "get_version_for_endpoint",
+        "EndpointConfig",
+        "ENDPOINTS",
+        "get_endpoint_url",
+        "get_version_for_endpoint",
     }
     if name in _endpoint_helpers:
         from hyperping import endpoints as _ep

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

@@ -178,6 +178,7 @@ class AsyncHyperpingClient(
             )
         if status in (400, 422):
             from hyperping.exceptions import HyperpingValidationError
+
             raise HyperpingValidationError(
                 message=f"Validation error: {error_msg}",
                 status_code=status,
@@ -321,9 +322,7 @@ class AsyncHyperpingClient(
                     continue
                 self._circuit_breaker.record_failure()
                 if isinstance(e, httpx.TimeoutException):
-                    raise HyperpingAPIError(
-                        f"Request timeout after {max_attempts} attempts"
-                    ) from e
+                    raise HyperpingAPIError(f"Request timeout after {max_attempts} attempts") from e
                 raise HyperpingAPIError(f"Request failed: {e}") from e
 
         raise HyperpingAPIError(  # pragma: no cover

{hyperping-1.2.1 → 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.2.1 → 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.2.1 → hyperping-1.4.0}/src/hyperping/_async_monitors_mixin.py

@@ -99,9 +99,7 @@ class AsyncMonitorsMixin(_AsyncClientProtocol):
         )
         payload.update(update.model_dump(exclude_none=True))
 
-        response = await self._request(
-            "PUT", f"{Endpoint.MONITORS}/{monitor_id}", json=payload
-        )
+        response = await self._request("PUT", f"{Endpoint.MONITORS}/{monitor_id}", json=payload)
         return Monitor.model_validate(expect_dict(response, "update_monitor"))
 
     async def delete_monitor(self, monitor_id: str) -> None:
@@ -156,9 +154,7 @@ class AsyncMonitorsMixin(_AsyncClientProtocol):
             HyperpingAPIError: On unexpected API errors.
         """
         if period not in VALID_PERIODS:
-            raise ValueError(
-                f"Invalid period {period!r}. Valid values: {sorted(VALID_PERIODS)}"
-            )
+            raise ValueError(f"Invalid period {period!r}. Valid values: {sorted(VALID_PERIODS)}")
         response = expect_dict(
             await self._request("GET", Endpoint.REPORTS, params={"period": period}),
             "get_all_reports",

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

@@ -56,9 +56,7 @@ class AsyncOutagesMixin(_AsyncClientProtocol):
             ValueError: If *status* or *outage_type* is not a recognised value.
         """
         if status not in _VALID_STATUSES:
-            raise ValueError(
-                f"Invalid status {status!r}. Valid values: {sorted(_VALID_STATUSES)}"
-            )
+            raise ValueError(f"Invalid status {status!r}. Valid values: {sorted(_VALID_STATUSES)}")
         if outage_type not in _VALID_TYPES:
             raise ValueError(
                 f"Invalid outage_type {outage_type!r}. Valid values: {sorted(_VALID_TYPES)}"
@@ -75,7 +73,8 @@ class AsyncOutagesMixin(_AsyncClientProtocol):
                 params["page"] = page
                 data = await self._request("GET", Endpoint.OUTAGES, params=params)
                 raw: list[Any] = (
-                    data.get("outages", []) if isinstance(data, dict)
+                    data.get("outages", [])
+                    if isinstance(data, dict)
                     else (data if isinstance(data, list) else [])
                 )
                 return parse_list(raw, Outage, "outage")
@@ -86,9 +85,7 @@ class AsyncOutagesMixin(_AsyncClientProtocol):
             logger.debug("Outage endpoint not available (404)")
             return []
 
-    async def acknowledge_outage(
-        self, outage_id: str, message: str | None = None
-    ) -> OutageAction:
+    async def acknowledge_outage(self, outage_id: str, message: str | None = None) -> OutageAction:
         """Acknowledge an outage.
 
         Args:
@@ -110,9 +107,7 @@ class AsyncOutagesMixin(_AsyncClientProtocol):
         )
         return OutageAction.from_raw(expect_dict(result, "outage operation"))
 
-    async def resolve_outage(
-        self, outage_id: str, message: str | None = None
-    ) -> OutageAction:
+    async def resolve_outage(self, outage_id: str, message: str | None = None) -> OutageAction:
         """Resolve an outage.
 
         Args:
@@ -163,9 +158,7 @@ class AsyncOutagesMixin(_AsyncClientProtocol):
             HyperpingNotFoundError: If outage not found.
         """
         validate_id(outage_id, "outage_id")
-        result = await self._request(
-            "POST", f"{Endpoint.OUTAGES}/{outage_id}/unacknowledge"
-        )
+        result = await self._request("POST", f"{Endpoint.OUTAGES}/{outage_id}/unacknowledge")
         return OutageAction.from_raw(expect_dict(result, "outage operation"))
 
     async def delete_outage(self, outage_id: str) -> None:

{hyperping-1.2.1 → 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.2.1 → 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.2.1 → 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.2.1 → 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