hyperping 1.1.0__tar.gz → 1.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperping
-Version: 1.1.0
+Version: 1.3.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
@@ -30,7 +30,7 @@ Requires-Dist: mypy>=1.10; extra == 'dev'
 Requires-Dist: pip-audit>=2.7; extra == 'dev'
 Requires-Dist: pydantic; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
-Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: pytest>=9.0.3; extra == 'dev'
 Requires-Dist: respx>=0.21; extra == 'dev'
 Requires-Dist: ruff>=0.4; extra == 'dev'
 Description-Content-Type: text/markdown

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hyperping"
-version = "1.1.0"
+version = "1.3.0"
 description = "Python SDK for the Hyperping uptime monitoring and incident management API"
 readme = {file = "README.md", content-type = "text/markdown"}
 license = {text = "MIT"}
@@ -31,7 +31,7 @@ dependencies = [
 
 [project.optional-dependencies]
 dev = [
-    "pytest>=8.0",
+    "pytest>=9.0.3",
     "pytest-cov",
     "respx>=0.21",
     "ruff>=0.4",

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

@@ -38,7 +38,9 @@ from hyperping.exceptions import (
 from hyperping.models import (
     DEFAULT_REGIONS,
     AddIncidentUpdateRequest,
+    AlertNotification,
     DnsRecordType,
+    EscalationPolicy,
     Healthcheck,
     HealthcheckCreate,
     HealthcheckUpdate,
@@ -49,11 +51,13 @@ from hyperping.models import (
     IncidentUpdate,
     IncidentUpdateRequest,
     IncidentUpdateType,
+    Integration,
     LocalizedText,
     Maintenance,
     MaintenanceCreate,
     MaintenanceUpdate,
     Monitor,
+    MonitorAnomaly,
     MonitorBase,
     MonitorCreate,
     MonitorFrequency,
@@ -63,10 +67,14 @@ from hyperping.models import (
     MonitorTimeout,
     MonitorUpdate,
     NotificationOption,
+    OnCallSchedule,
     Outage,
     OutageAction,
     OutageDetail,
     OutageStats,
+    OutageTimeline,
+    OutageTimelineEvent,
+    ProbeLog,
     Region,
     ReportPeriod,
     RequestHeader,
@@ -74,6 +82,7 @@ from hyperping.models import (
     StatusPageCreate,
     StatusPageSubscriber,
     StatusPageUpdate,
+    StatusSummary,
 )
 
 __all__ = [
@@ -137,6 +146,19 @@ __all__ = [
     # Outages
     "Outage",
     "OutageAction",
+    "OutageTimeline",
+    "OutageTimelineEvent",
+    # Observability
+    "MonitorAnomaly",
+    "ProbeLog",
+    "AlertNotification",
+    # On-call
+    "OnCallSchedule",
+    "EscalationPolicy",
+    # Integrations
+    "Integration",
+    # Reporting
+    "StatusSummary",
     # Healthchecks
     "Healthcheck",
     "HealthcheckCreate",
@@ -161,8 +183,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 +191,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 +219,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.1.0 → hyperping-1.3.0}/src/hyperping/_async_client.py

@@ -21,9 +21,13 @@ 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,
@@ -48,6 +52,10 @@ class AsyncHyperpingClient(
     AsyncOutagesMixin,
     AsyncStatusPagesMixin,
     AsyncHealthchecksMixin,
+    AsyncReportingMixin,
+    AsyncObservabilityMixin,
+    AsyncOnCallMixin,
+    AsyncIntegrationsMixin,
 ):
     """Async client for interacting with the Hyperping API.
 
@@ -178,6 +186,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 +330,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.3.0/src/hyperping/_async_integrations_mixin.py

@@ -0,0 +1,26 @@
+"""Async integrations mixin: notification channel management."""
+
+from hyperping._protocols import _AsyncClientProtocol
+from hyperping._utils import expect_dict, parse_list, validate_id
+from hyperping.endpoints import Endpoint
+from hyperping.exceptions import HyperpingAPIError, HyperpingNotFoundError
+from hyperping.models._integration_models import Integration
+
+
+class AsyncIntegrationsMixin(_AsyncClientProtocol):
+    """Async integration API operations."""
+
+    async def list_integrations(self) -> list[Integration]:
+        """Get all configured notification integrations."""
+        try:
+            result = await self._request("GET", Endpoint.INTEGRATIONS)
+        except (HyperpingNotFoundError, HyperpingAPIError):
+            return []
+        items = result if isinstance(result, list) else []
+        return parse_list(items, Integration, "integration")
+
+    async def get_integration(self, integration_id: str) -> Integration:
+        """Get a single integration."""
+        validate_id(integration_id, "integration_id")
+        result = await self._request("GET", f"{Endpoint.INTEGRATIONS}/{integration_id}")
+        return Integration.model_validate(expect_dict(result, "get_integration"))

{hyperping-1.1.0 → hyperping-1.3.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",
@@ -191,3 +187,16 @@ 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/src/hyperping/_async_observability_mixin.py

@@ -0,0 +1,65 @@
+"""Async observability mixin: anomalies, probe logs, alert history."""
+
+from typing import Any
+
+from hyperping._protocols import _AsyncClientProtocol
+from hyperping._utils import parse_list, validate_id
+from hyperping.endpoints import Endpoint
+from hyperping.exceptions import HyperpingAPIError, HyperpingNotFoundError
+from hyperping.models._observability_models import (
+    AlertNotification,
+    MonitorAnomaly,
+    ProbeLog,
+)
+
+
+class AsyncObservabilityMixin(_AsyncClientProtocol):
+    """Async observability API operations."""
+
+    async def get_monitor_anomalies(self, monitor_uuid: str) -> list[MonitorAnomaly]:
+        """Get detected anomalies for a monitor."""
+        validate_id(monitor_uuid, "monitor_uuid")
+        try:
+            result = await self._request("GET", f"{Endpoint.MONITORS}/{monitor_uuid}/anomalies")
+        except (HyperpingNotFoundError, HyperpingAPIError):
+            return []
+        items = result if isinstance(result, list) else []
+        return parse_list(items, MonitorAnomaly, "anomaly")
+
+    async def get_monitor_http_logs(
+        self, monitor_uuid: str, page: int = 0, limit: int = 50, level: str | None = None
+    ) -> list[ProbeLog]:
+        """Get recent HTTP probe logs for a monitor."""
+        validate_id(monitor_uuid, "monitor_uuid")
+        params: dict[str, Any] = {"page": page, "limit": limit}
+        if level is not None:
+            params["level"] = level
+        try:
+            result = await self._request(
+                "GET", f"{Endpoint.MONITORS}/{monitor_uuid}/http-logs", params=params
+            )
+        except (HyperpingNotFoundError, HyperpingAPIError):
+            return []
+        items = result if isinstance(result, list) else []
+        return parse_list(items, ProbeLog, "probe_log")
+
+    async def list_recent_alerts(
+        self,
+        from_dt: str | None = None,
+        to_dt: str | None = None,
+        monitor_uuids: list[str] | None = None,
+    ) -> list[AlertNotification]:
+        """Get recent alert notification history."""
+        params: dict[str, Any] = {}
+        if from_dt is not None:
+            params["from"] = from_dt
+        if to_dt is not None:
+            params["to"] = to_dt
+        if monitor_uuids:
+            params["monitor_uuids"] = ",".join(monitor_uuids)
+        try:
+            result = await self._request("GET", Endpoint.ALERTS, params=params)
+        except (HyperpingNotFoundError, HyperpingAPIError):
+            return []
+        items = result if isinstance(result, list) else []
+        return parse_list(items, AlertNotification, "alert")

hyperping-1.3.0/src/hyperping/_async_oncall_mixin.py

@@ -0,0 +1,53 @@
+"""Async on-call mixin: schedules, escalation policies, team members."""
+
+from typing import Any
+
+from hyperping._protocols import _AsyncClientProtocol
+from hyperping._utils import expect_dict, parse_list, validate_id
+from hyperping.endpoints import Endpoint
+from hyperping.exceptions import HyperpingAPIError, HyperpingNotFoundError
+from hyperping.models._oncall_models import EscalationPolicy, OnCallSchedule
+
+
+class AsyncOnCallMixin(_AsyncClientProtocol):
+    """Async on-call context API operations."""
+
+    async def list_on_call_schedules(self) -> list[OnCallSchedule]:
+        """Get all on-call rotation schedules."""
+        try:
+            result = await self._request("GET", Endpoint.ON_CALL_SCHEDULES)
+        except (HyperpingNotFoundError, HyperpingAPIError):
+            return []
+        items = result if isinstance(result, list) else []
+        return parse_list(items, OnCallSchedule, "on_call_schedule")
+
+    async def get_on_call_schedule(self, schedule_id: str) -> OnCallSchedule:
+        """Get a single on-call schedule."""
+        validate_id(schedule_id, "schedule_id")
+        result = await self._request("GET", f"{Endpoint.ON_CALL_SCHEDULES}/{schedule_id}")
+        return OnCallSchedule.model_validate(expect_dict(result, "get_on_call_schedule"))
+
+    async def list_escalation_policies(self) -> list[EscalationPolicy]:
+        """Get all escalation policies."""
+        try:
+            result = await self._request("GET", Endpoint.ESCALATION_POLICIES)
+        except (HyperpingNotFoundError, HyperpingAPIError):
+            return []
+        items = result if isinstance(result, list) else []
+        return parse_list(items, EscalationPolicy, "escalation_policy")
+
+    async def get_escalation_policy(self, policy_id: str) -> EscalationPolicy:
+        """Get a single escalation policy."""
+        validate_id(policy_id, "policy_id")
+        result = await self._request("GET", f"{Endpoint.ESCALATION_POLICIES}/{policy_id}")
+        return EscalationPolicy.model_validate(expect_dict(result, "get_escalation_policy"))
+
+    async def list_team_members(self) -> list[dict[str, Any]]:
+        """Get all team members."""
+        try:
+            result = await self._request("GET", Endpoint.TEAM_MEMBERS)
+        except (HyperpingNotFoundError, HyperpingAPIError):
+            return []
+        if isinstance(result, list):
+            return result
+        return []

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

@@ -19,6 +19,7 @@ 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__)
 
@@ -56,9 +57,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 +74,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 +86,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 +108,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 +159,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:
@@ -212,3 +206,33 @@ 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/src/hyperping/_async_reporting_mixin.py

@@ -0,0 +1,39 @@
+"""Async reporting mixin: status summary, response time, MTTA."""
+
+from typing import Any
+
+from hyperping._protocols import _AsyncClientProtocol
+from hyperping._utils import expect_dict, validate_id
+from hyperping.endpoints import Endpoint
+from hyperping.models._reporting_models import StatusSummary
+
+
+class AsyncReportingMixin(_AsyncClientProtocol):
+    """Async status and reporting API operations."""
+
+    async def get_status_summary(self) -> StatusSummary:
+        """Get aggregate status counts for the project."""
+        result = await self._request("GET", Endpoint.STATUS_SUMMARY)
+        return StatusSummary.model_validate(expect_dict(result, "get_status_summary"))
+
+    async def get_monitor_response_time(
+        self, monitor_uuid: str, period: str = "24h"
+    ) -> dict[str, Any]:
+        """Get latency percentiles for a monitor."""
+        validate_id(monitor_uuid, "monitor_uuid")
+        result = await self._request(
+            "GET",
+            f"{Endpoint.MONITOR_RESPONSE_TIME}/{monitor_uuid}",
+            params={"period": period},
+        )
+        return expect_dict(result, "get_monitor_response_time")
+
+    async def get_monitor_mtta(self, monitor_uuid: str, period: str = "30d") -> dict[str, Any]:
+        """Get Mean Time To Acknowledge for a monitor."""
+        validate_id(monitor_uuid, "monitor_uuid")
+        result = await self._request(
+            "GET",
+            f"{Endpoint.MONITOR_MTTA}/{monitor_uuid}",
+            params={"period": period},
+        )
+        return expect_dict(result, "get_monitor_mtta")

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

@@ -12,6 +12,7 @@ from datetime import UTC, datetime
 from hyperping._protocols import _ClientProtocol
 from hyperping._utils import expect_dict, parse_list, unwrap_list, validate_id
 from hyperping.endpoints import Endpoint
+from hyperping.exceptions import HyperpingAPIError
 from hyperping.models import (
     AddIncidentUpdateRequest,  # canonical name (M18)
     Incident,
@@ -144,7 +145,16 @@ class IncidentsMixin(_ClientProtocol):
         payload = update.model_dump(exclude_none=True, by_alias=True)
         url = f"{Endpoint.INCIDENTS}/{incident_id}/updates"
         self._request("POST", url, json=payload)  # Returns {"message": "..."} — not a full Incident
-        return self.get_incident(incident_id)
+        try:
+            return self.get_incident(incident_id)
+        except HyperpingAPIError as exc:
+            raise HyperpingAPIError(
+                f"Incident update was posted successfully but refreshing "
+                f"incident {incident_id!r} failed: {exc}",
+                status_code=exc.status_code,
+                response_body=exc.response_body,
+                request_id=exc.request_id,
+            ) from exc
 
     def resolve_incident(self, incident_id: str, message: str | None = None) -> Incident:
         """Resolve an incident.

hyperping-1.3.0/src/hyperping/_integrations_mixin.py

@@ -0,0 +1,41 @@
+"""Integrations mixin: notification channel management."""
+
+from hyperping._protocols import _ClientProtocol
+from hyperping._utils import expect_dict, parse_list, validate_id
+from hyperping.endpoints import Endpoint
+from hyperping.exceptions import HyperpingAPIError, HyperpingNotFoundError
+from hyperping.models._integration_models import Integration
+
+
+class IntegrationsMixin(_ClientProtocol):
+    """Integration API operations."""
+
+    def list_integrations(self) -> list[Integration]:
+        """Get all configured notification integrations.
+
+        Returns:
+            List of :class:`~hyperping.models.Integration` objects.
+            Returns empty list on 404.
+        """
+        try:
+            result = self._request("GET", Endpoint.INTEGRATIONS)
+        except (HyperpingNotFoundError, HyperpingAPIError):
+            return []
+        items = result if isinstance(result, list) else []
+        return parse_list(items, Integration, "integration")
+
+    def get_integration(self, integration_id: str) -> Integration:
+        """Get a single integration.
+
+        Args:
+            integration_id: Integration UUID.
+
+        Returns:
+            :class:`~hyperping.models.Integration` object.
+
+        Raises:
+            HyperpingNotFoundError: If integration not found.
+        """
+        validate_id(integration_id, "integration_id")
+        result = self._request("GET", f"{Endpoint.INTEGRATIONS}/{integration_id}")
+        return Integration.model_validate(expect_dict(result, "get_integration"))

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

@@ -125,12 +125,11 @@ class MaintenanceMixin(_ClientProtocol):
         current = self.get_maintenance(maintenance_id)
         partial = update.model_dump(exclude_none=True, by_alias=True, mode="json")
 
-        payload: dict[str, object] = {
-            "name": current.name,
-            "start_date": current.start_date,
-            "end_date": current.end_date,
-            "monitors": current.monitors,
-        }
+        payload: dict[str, object] = current.model_dump(
+            mode="json",
+            exclude_none=True,
+            include={"name", "start_date", "end_date", "monitors"},
+        )
         payload.update(partial)
 
         response = expect_dict(

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

@@ -171,9 +171,7 @@ class MonitorsMixin(_ClientProtocol):
             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(
             self._request("GET", Endpoint.REPORTS, params={"period": period}),
             "get_all_reports",
@@ -215,3 +213,23 @@ 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")