hyperping 1.3.0__tar.gz → 1.4.1__tar.gz

{hyperping-1.3.0 → hyperping-1.4.1}/CHANGELOG.md

@@ -5,6 +5,87 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.4.1] - 2026-04-20
+
+### Fixed
+
+- HTTP 403 from MCP server now correctly raises `HyperpingAuthError` (was
+  `HyperpingAPIError`). The Hyperping MCP server returns 403 for invalid API keys;
+  the transport only handled 401. Now matches REST client behavior.
+- `MCP_URL` defined in single location (`endpoints.py`); removed duplicate in
+  `_mcp_transport.py`.
+- MCP handshake version string uses `__version__` instead of hardcoded `"1.4.0"`.
+
+## [1.4.0] - 2026-04-19
+
+### Added
+
+- **`HyperpingMcpClient`** -- new client for Hyperping MCP server features not available
+  via the REST API. Uses JSON-RPC 2.0 over HTTP at `/v1/mcp` with the same Bearer token
+  API key. Provides 16 typed methods: `get_status_summary`, `get_monitor_response_time`,
+  `get_monitor_mtta`, `get_monitor_mttr`, `get_monitor_anomalies`, `get_monitor_http_logs`,
+  `list_recent_alerts`, `list_on_call_schedules`, `get_on_call_schedule`,
+  `list_escalation_policies`, `get_escalation_policy`, `list_team_members`,
+  `list_integrations`, `get_integration`, `get_outage_timeline`, `search_monitors_by_name`.
+- **`McpTransport`** -- low-level JSON-RPC 2.0 transport with auto-initialization handshake,
+  double-parse response extraction, and error mapping to existing SDK exception types.
+- **`MCP_URL`** constant exported from `hyperping` top-level.
+- **Sync outage methods** -- `create_outage`, `delete_outage`, `get_outage`,
+  `unacknowledge_outage` added to `OutagesMixin` (were only in async client).
+- **Verification script** -- `scripts/verify_endpoints.py` for testing endpoints against
+  the live API.
+
+### Changed
+
+- **Maintenance update** uses `model_dump(include=...)` instead of hard-coded field list.
+- **Incident update error handling** -- `add_incident_update` now provides context when
+  the POST succeeds but the follow-up GET fails.
+
+### Removed
+
+- **Speculative REST methods** -- 12 methods that called nonexistent REST endpoints
+  (on-call, alerts, anomalies, integrations, probe logs, response time, MTTA, status
+  summary, outage timeline, monitor search) removed from `HyperpingClient` and
+  `AsyncHyperpingClient`. These features are MCP-only; use `HyperpingMcpClient` instead.
+- **8 speculative mixin files** (sync + async) deleted.
+- **8 speculative Endpoint enum entries** removed from `endpoints.py`.
+
+### Fixed
+
+- HTTP 403 from MCP server now correctly raises `HyperpingAuthError` (was
+  `HyperpingAPIError`). Matches REST client behavior.
+- `MCP_URL` defined in single location (`endpoints.py`), not duplicated.
+- MCP handshake version uses `__version__` instead of hardcoded string.
+- `pytest` bumped to 9.0.3 (CVE-2025-71176).
+
+## [1.3.0] - 2026-04-18 [YANKED]
+
+v1.3.0 added 18 speculative REST methods for MCP-discovered features (reporting,
+observability, on-call, integrations). All 12 endpoint paths were guessed from MCP
+tool names and **none of them work via the REST API** (verified: 10x 404, 2x 401).
+These features are only accessible through the MCP server (JSON-RPC 2.0). Superseded
+by v1.4.0 which replaces the broken REST methods with a proper `HyperpingMcpClient`.
+
+## [1.2.1] - 2026-04-17
+
+### Fixed
+
+- Bump `pytest` to 9.0.3 (CVE-2025-71176).
+
+## [1.2.0] - 2026-04-17
+
+### Added
+
+- **Sync outage methods** -- `create_outage`, `delete_outage`, `get_outage`,
+  `unacknowledge_outage` added to `OutagesMixin` for feature parity with async client.
+
+### Changed
+
+- **Maintenance update** uses `model_dump(include=...)` instead of hard-coded field
+  enumeration for robustness.
+- **Incident update error handling** -- `add_incident_update` now provides context when
+  the POST succeeds but the follow-up GET fails.
+
 ## [1.1.0] - 2026-04-09
 
 ### Added
@@ -30,6 +111,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **`collect_all_pages` / `collect_all_pages_async`** helpers in `_utils.py` for
   transparent multi-page result aggregation.
 
+## [1.0.1] - 2026-04-05
+
+### Fixed
+
+- Fix version string in `pyproject.toml` (was out of sync with `_version.py`).
+- Fix package metadata: incorrect email address in project config.
+
 ## [1.0.0] - 2026-04-05
 
 First stable release. The public API is production-ready and covered by semver

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperping
-Version: 1.3.0
+Version: 1.4.1
 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
@@ -181,6 +181,43 @@ sub  = client.add_subscriber("sp_uuid", "user@example.com")
 client.remove_subscriber("sp_uuid", sub.id)
 ```
 
+### MCP Client (on-call, alerts, anomalies, integrations)
+
+Some Hyperping features are only available via the MCP server (JSON-RPC 2.0),
+not the REST API. Use `HyperpingMcpClient` for these:
+
+```python
+from hyperping import HyperpingMcpClient
+
+with HyperpingMcpClient(api_key="sk_...") as mcp:
+    # Status & reporting
+    summary = mcp.get_status_summary()
+    mtta = mcp.get_monitor_mtta("mon_uuid")
+    mttr = mcp.get_monitor_mttr("mon_uuid")
+    response_time = mcp.get_monitor_response_time("mon_uuid")
+
+    # On-call & escalation
+    schedules = mcp.list_on_call_schedules()
+    policies = mcp.list_escalation_policies()
+    members = mcp.list_team_members()
+
+    # Observability
+    anomalies = mcp.get_monitor_anomalies("mon_uuid")
+    logs = mcp.get_monitor_http_logs("mon_uuid")
+    alerts = mcp.list_recent_alerts()
+
+    # Integrations
+    integrations = mcp.list_integrations()
+
+    # Outage timeline & monitor search
+    timeline = mcp.get_outage_timeline("out_uuid")
+    results = mcp.search_monitors_by_name("api")
+```
+
+The MCP client uses the same API key as `HyperpingClient`. All methods return
+plain dicts/lists; use the exported Pydantic models (e.g., `OnCallSchedule`,
+`EscalationPolicy`) for validation if needed.
+
 ### Healthchecks
 
 ```python

{hyperping-1.3.0 → hyperping-1.4.1}/README.md

@@ -144,6 +144,43 @@ sub  = client.add_subscriber("sp_uuid", "user@example.com")
 client.remove_subscriber("sp_uuid", sub.id)
 ```
 
+### MCP Client (on-call, alerts, anomalies, integrations)
+
+Some Hyperping features are only available via the MCP server (JSON-RPC 2.0),
+not the REST API. Use `HyperpingMcpClient` for these:
+
+```python
+from hyperping import HyperpingMcpClient
+
+with HyperpingMcpClient(api_key="sk_...") as mcp:
+    # Status & reporting
+    summary = mcp.get_status_summary()
+    mtta = mcp.get_monitor_mtta("mon_uuid")
+    mttr = mcp.get_monitor_mttr("mon_uuid")
+    response_time = mcp.get_monitor_response_time("mon_uuid")
+
+    # On-call & escalation
+    schedules = mcp.list_on_call_schedules()
+    policies = mcp.list_escalation_policies()
+    members = mcp.list_team_members()
+
+    # Observability
+    anomalies = mcp.get_monitor_anomalies("mon_uuid")
+    logs = mcp.get_monitor_http_logs("mon_uuid")
+    alerts = mcp.list_recent_alerts()
+
+    # Integrations
+    integrations = mcp.list_integrations()
+
+    # Outage timeline & monitor search
+    timeline = mcp.get_outage_timeline("out_uuid")
+    results = mcp.search_monitors_by_name("api")
+```
+
+The MCP client uses the same API key as `HyperpingClient`. All methods return
+plain dicts/lists; use the exported Pydantic models (e.g., `OnCallSchedule`,
+`EscalationPolicy`) for validation if needed.
+
 ### Healthchecks
 
 ```python

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hyperping"
-version = "1.3.0"
+version = "1.4.1"
 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.1/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.1}/src/hyperping/__init__.py

@@ -25,6 +25,7 @@ from hyperping.client import (
 )
 from hyperping.endpoints import (
     API_BASE,
+    MCP_URL,
     APIVersion,
     Endpoint,
 )
@@ -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.1}/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.1}/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.1}/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.1}/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.1}/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.1}/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.1}/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.1}/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.1}/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