hyperping 1.8.0__tar.gz → 1.9.0__tar.gz

{hyperping-1.8.0 → hyperping-1.9.0}/CHANGELOG.md

@@ -7,6 +7,81 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.9.0] - 2026-07-14
+
+Corrective minor release. It renames the bundled console script (breaking) and
+retroactively documents breaking changes that shipped mislabeled in 1.8.0/1.8.1
+(see Upgrade Notes). If you pinned `~=1.8.0` or `~=1.8.1` you already received
+those breaking changes silently; this entry explains them.
+
+### BREAKING
+
+- **The bundled console script is renamed `hyp` → `hyperping`.** 1.8.1 introduced
+  a `hyp` entry point for the SDK's CLI. `hyp` is the long-standing command of the
+  separate `hyperping-automation` tool; when both are installed the SDK's script
+  silently shadowed it (last-writer-wins on `bin/hyp`), breaking that tool's
+  commands and exposing the SDK's unguarded write commands under a familiar name.
+  Invoke the SDK CLI as `hyperping …` now. (Removing/renaming a console script is
+  a breaking change; it is the reason this is 1.9.0, not 1.8.2.)
+
+### Fixed
+
+- **`create_maintenance_windows` / `create_incidents` now surface partial failures.**
+  If a later chunk fails after earlier objects were created, they raise
+  `HyperpingPartialBatchError` carrying the already-created objects (`.created`,
+  `.completed`, `.total`) instead of discarding them, so callers can record or
+  clean up rather than orphaning windows/incidents silently.
+
+### Added
+
+- **`create_incidents()`** (sync + async): splits a broadcast incident's status
+  pages into chunks of at most `MAX_STATUSPAGES_PER_INCIDENT` (51), mirroring
+  `create_maintenance_windows`. `create_incident()` now raises
+  `HyperpingValidationError` above the cap instead of silently failing to persist.
+  NOTE: the 51 cap for incidents is assumed identical to maintenance (same
+  status-page attachment path) and has not been independently measured against
+  the live API.
+- **`HyperpingPartialBatchError`** and **`MAX_STATUSPAGES_PER_INCIDENT`** exported
+  from the package root.
+
+### Upgrade Notes (breaking changes that shipped mislabeled in 1.8.0 / 1.8.1)
+
+These are not new in 1.9.0; they are documented here because 1.8.0/1.8.1 changed
+them without an upgrade note, which is why consumers were caught out:
+
+- **1.8.0** reconciled the `Integration`, `EscalationPolicy`, and `TeamMember`
+  models against the production API: `Integration.active` was **removed** and the
+  integration-type field key is now **`channel`** (was `type`); a new
+  `EscalationStep` shape was introduced. Any code reading `Integration.active` or
+  sending `type=` breaks.
+- **1.8.1** added the `hyp` console script (renamed here) and the status-page /
+  maintenance fixes; it was released as a patch despite the CLI addition.
+
+Guidance: pin `hyperping>=1.9.0,<2` and, if you consume the CLI, use `hyperping`.
+
+## [1.8.1] - 2026-07-14
+
+### Fixed
+
+- **`list_status_pages()` returned an empty list against the live v2 API.** The
+  `StatusPage` model required a `subdomain` field, but the API returns the hosted
+  subdomain under the key `hostedsubdomain` (and omits it entirely for custom-domain
+  pages). Every record failed validation and was silently skipped. `subdomain` is now
+  optional and aliased to `hostedsubdomain`; `hostname` and `url` are also parsed.
+
+### Added
+
+- **`create_maintenance()` now guards against the silent status-page overflow.**
+  Hyperping's v1 maintenance-windows API accepts a create with more than 51 status
+  pages (returns a uuid) but never persists the window. `create_maintenance` now raises
+  `HyperpingValidationError` when `statuspages` exceeds `MAX_STATUSPAGES_PER_MAINTENANCE`
+  (51), instead of returning a phantom window. Split larger sets across multiple windows.
+- **`create_maintenance_windows()`** (sync + async): convenience helper that splits a
+  large `statuspages` list into consecutive windows of at most 51 pages, so callers can
+  cover more pages than one window allows. Each window carries the full monitor set (the
+  API requires at least one monitor per window). `MAX_STATUSPAGES_PER_MAINTENANCE` is
+  exported for callers that chunk themselves (e.g. a broadcast-to-all-tenants command).
+
 ## [1.8.0] - 2026-05-31
 
 This is a security-focused release. It closes several credential-leak and validation gaps surfaced by an independent audit. One change is breaking for local-development workflows; see Upgrade Notes below.

{hyperping-1.8.0 → hyperping-1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperping
-Version: 1.8.0
+Version: 1.9.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
@@ -12,6 +12,7 @@ License: MIT
 License-File: LICENSE
 Keywords: api-client,httpx,hyperping,incident,monitoring,pydantic,python,sdk,status-page,uptime
 Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
@@ -25,6 +26,8 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Requires-Dist: httpx<1.0,>=0.27
 Requires-Dist: pydantic<3.0,>=2.0
+Provides-Extra: cli
+Requires-Dist: typer[all]<1.0,>=0.12; extra == 'cli'
 Provides-Extra: dev
 Requires-Dist: mypy>=1.10; extra == 'dev'
 Requires-Dist: pip-audit>=2.7; extra == 'dev'
@@ -33,6 +36,7 @@ Requires-Dist: pytest-cov; extra == 'dev'
 Requires-Dist: pytest>=9.0.3; extra == 'dev'
 Requires-Dist: respx>=0.21; extra == 'dev'
 Requires-Dist: ruff>=0.4; extra == 'dev'
+Requires-Dist: typer[all]<1.0,>=0.12; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # hyperping

{hyperping-1.8.0 → hyperping-1.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hyperping"
-version = "1.8.0"
+version = "1.9.0"
 description = "Python SDK for the Hyperping uptime monitoring and incident management API"
 readme = {file = "README.md", content-type = "text/markdown"}
 license = {text = "MIT"}
@@ -23,6 +23,7 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
     "Topic :: Internet :: WWW/HTTP",
     "Typing :: Typed",
+    "Environment :: Console",
 ]
 dependencies = [
     "httpx>=0.27,<1.0",
@@ -30,6 +31,7 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
+cli = ["typer[all]>=0.12,<1.0"]
 dev = [
     "pytest>=9.0.3",
     "pytest-cov",
@@ -38,8 +40,15 @@ dev = [
     "mypy>=1.10",
     "pydantic",
     "pip-audit>=2.7",
+    "typer[all]>=0.12,<1.0",
 ]
 
+[project.scripts]
+# Console script is 'hyperping' (NOT 'hyp'): 'hyp' collides with the long-lived
+# hyperping-automation CLI (hyp_status) and, when both are installed, silently
+# shadows it. See CHANGELOG 1.9.0 BREAKING notes.
+hyperping = "hyperping.cli._app:app"
+
 [project.urls]
 Homepage      = "https://github.com/develeap/hyperping-python"
 Documentation = "https://github.com/develeap/hyperping-python#readme"

{hyperping-1.8.0 → hyperping-1.9.0}/src/hyperping/__init__.py

@@ -16,6 +16,8 @@ Quick start::
 
 from hyperping._async_client import AsyncHyperpingClient
 from hyperping._async_mcp_client import AsyncHyperpingMcpClient
+from hyperping._incidents_mixin import MAX_STATUSPAGES_PER_INCIDENT
+from hyperping._maintenance_mixin import MAX_STATUSPAGES_PER_MAINTENANCE
 from hyperping._version import __version__
 from hyperping.client import (
     CircuitBreaker,
@@ -34,6 +36,7 @@ from hyperping.exceptions import (
     HyperpingAPIError,
     HyperpingAuthError,
     HyperpingNotFoundError,
+    HyperpingPartialBatchError,
     HyperpingRateLimitError,
     HyperpingValidationError,
 )
@@ -44,6 +47,7 @@ from hyperping.models import (
     AlertHistory,
     DnsRecordType,
     EscalationPolicy,
+    EscalationStep,
     Healthcheck,
     HealthcheckCreate,
     HealthcheckUpdate,
@@ -116,6 +120,7 @@ __all__ = [
     "APIVersion",
     # Exceptions
     "HyperpingAPIError",
+    "HyperpingPartialBatchError",
     "HyperpingAuthError",
     "HyperpingNotFoundError",
     "HyperpingRateLimitError",
@@ -149,6 +154,8 @@ __all__ = [
     "IncidentStatus",
     "IncidentUpdateCreate",
     # Maintenance
+    "MAX_STATUSPAGES_PER_INCIDENT",
+    "MAX_STATUSPAGES_PER_MAINTENANCE",
     "Maintenance",
     "MaintenanceCreate",
     "MaintenanceUpdate",
@@ -168,6 +175,7 @@ __all__ = [
     "ProbeLogResponse",
     # On-call
     "OnCallSchedule",
+    "EscalationStep",
     "EscalationPolicy",
     "TeamMember",
     # Integrations

{hyperping-1.8.0 → hyperping-1.9.0}/src/hyperping/_async_incidents_mixin.py

@@ -9,9 +9,15 @@ from __future__ import annotations
 import logging
 from datetime import UTC, datetime
 
+from hyperping._incidents_mixin import MAX_STATUSPAGES_PER_INCIDENT
 from hyperping._protocols import _AsyncClientProtocol
 from hyperping._utils import expect_dict, parse_list, unwrap_list, validate_id
 from hyperping.endpoints import Endpoint
+from hyperping.exceptions import (
+    HyperpingAPIError,
+    HyperpingPartialBatchError,
+    HyperpingValidationError,
+)
 from hyperping.models import (
     AddIncidentUpdateRequest,
     Incident,
@@ -81,6 +87,15 @@ class AsyncIncidentsMixin(_AsyncClientProtocol):
             v3 API returns {"message": "...", "uuid": "..."} on create,
             not the full incident object. The full incident is fetched after creation.
         """
+        n_statuspages = len(incident.statuspages or [])
+        if n_statuspages > MAX_STATUSPAGES_PER_INCIDENT:
+            raise HyperpingValidationError(
+                f"An incident can reference at most {MAX_STATUSPAGES_PER_INCIDENT} "
+                f"status pages, but {n_statuspages} were supplied. Above this limit "
+                f"Hyperping's API is expected to accept the create (returns a uuid) but "
+                f"silently fail to persist it. Use create_incidents() to split the "
+                f"status pages across multiple incidents."
+            )
         payload = incident.model_dump(exclude_none=True, by_alias=True, mode="json")
         response = expect_dict(
             await self._request("POST", Endpoint.INCIDENTS, json=payload),
@@ -90,6 +105,40 @@ class AsyncIncidentsMixin(_AsyncClientProtocol):
             return await self.get_incident(response["uuid"])
         return Incident.model_validate(response)
 
+    async def create_incidents(
+        self,
+        incident: IncidentCreate,
+        *,
+        chunk_size: int = MAX_STATUSPAGES_PER_INCIDENT,
+    ) -> list[Incident]:
+        """Async mirror of
+        :meth:`~hyperping._incidents_mixin.IncidentsMixin.create_incidents`.
+        """
+        if not 1 <= chunk_size <= MAX_STATUSPAGES_PER_INCIDENT:
+            raise HyperpingValidationError(
+                f"chunk_size must be between 1 and "
+                f"{MAX_STATUSPAGES_PER_INCIDENT}, got {chunk_size}."
+            )
+        pages = list(incident.statuspages or [])
+        if len(pages) <= chunk_size:
+            return [await self.create_incident(incident)]
+        chunks = [pages[i : i + chunk_size] for i in range(0, len(pages), chunk_size)]
+        created: list[Incident] = []
+        for idx, chunk_pages in enumerate(chunks):
+            chunk = incident.model_copy(update={"statuspages": chunk_pages})
+            try:
+                created.append(await self.create_incident(chunk))
+            except HyperpingAPIError as exc:
+                raise HyperpingPartialBatchError(
+                    f"create_incidents failed on incident {idx + 1} of "
+                    f"{len(chunks)}: {exc}. {len(created)} incident(s) were already "
+                    f"created and remain live.",
+                    created=created,
+                    completed=len(created),
+                    total=len(chunks),
+                ) from exc
+        return created
+
     async def update_incident(
         self,
         incident_id: str,

{hyperping-1.8.0 → hyperping-1.9.0}/src/hyperping/_async_maintenance_mixin.py

@@ -9,9 +9,15 @@ from __future__ import annotations
 import logging
 from datetime import UTC, datetime
 
+from hyperping._maintenance_mixin import MAX_STATUSPAGES_PER_MAINTENANCE
 from hyperping._protocols import _AsyncClientProtocol
 from hyperping._utils import expect_dict, parse_list, unwrap_list, validate_id
 from hyperping.endpoints import Endpoint
+from hyperping.exceptions import (
+    HyperpingAPIError,
+    HyperpingPartialBatchError,
+    HyperpingValidationError,
+)
 from hyperping.models import (
     Maintenance,
     MaintenanceCreate,
@@ -82,6 +88,15 @@ class AsyncMaintenanceMixin(_AsyncClientProtocol):
             v1 API returns {"uuid": "..."} on create, not the full maintenance object.
             The full maintenance window is fetched after creation.
         """
+        n_statuspages = len(maintenance.statuspages or [])
+        if n_statuspages > MAX_STATUSPAGES_PER_MAINTENANCE:
+            raise HyperpingValidationError(
+                f"A maintenance window can reference at most "
+                f"{MAX_STATUSPAGES_PER_MAINTENANCE} status pages, but {n_statuspages} "
+                f"were supplied. Above this limit Hyperping's API accepts the create "
+                f"(returns a uuid) but silently fails to persist the window. Split the "
+                f"status pages across multiple maintenance windows."
+            )
         payload = maintenance.model_dump(exclude_none=True, by_alias=True, mode="json")
         response = expect_dict(
             await self._request("POST", Endpoint.MAINTENANCE, json=payload),
@@ -91,6 +106,42 @@ class AsyncMaintenanceMixin(_AsyncClientProtocol):
             return await self.get_maintenance(response["uuid"])
         return Maintenance.model_validate(response)
 
+    async def create_maintenance_windows(
+        self,
+        maintenance: MaintenanceCreate,
+        *,
+        chunk_size: int = MAX_STATUSPAGES_PER_MAINTENANCE,
+    ) -> list[Maintenance]:
+        """Create one or more windows, splitting status pages into chunks.
+
+        Async mirror of
+        :meth:`~hyperping._maintenance_mixin.MaintenanceMixin.create_maintenance_windows`.
+        """
+        if not 1 <= chunk_size <= MAX_STATUSPAGES_PER_MAINTENANCE:
+            raise HyperpingValidationError(
+                f"chunk_size must be between 1 and "
+                f"{MAX_STATUSPAGES_PER_MAINTENANCE}, got {chunk_size}."
+            )
+        pages = list(maintenance.statuspages or [])
+        if len(pages) <= chunk_size:
+            return [await self.create_maintenance(maintenance)]
+        chunks = [pages[i : i + chunk_size] for i in range(0, len(pages), chunk_size)]
+        windows: list[Maintenance] = []
+        for idx, chunk_pages in enumerate(chunks):
+            chunk = maintenance.model_copy(update={"statuspages": chunk_pages})
+            try:
+                windows.append(await self.create_maintenance(chunk))
+            except HyperpingAPIError as exc:
+                raise HyperpingPartialBatchError(
+                    f"create_maintenance_windows failed on window {idx + 1} of "
+                    f"{len(chunks)}: {exc}. {len(windows)} window(s) were already "
+                    f"created and remain live.",
+                    created=windows,
+                    completed=len(windows),
+                    total=len(chunks),
+                ) from exc
+        return windows
+
     async def update_maintenance(
         self,
         maintenance_id: str,

{hyperping-1.8.0 → hyperping-1.9.0}/src/hyperping/_async_mcp_client.py

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

{hyperping-1.8.0 → hyperping-1.9.0}/src/hyperping/_incidents_mixin.py

@@ -12,7 +12,11 @@ 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.exceptions import (
+    HyperpingAPIError,
+    HyperpingPartialBatchError,
+    HyperpingValidationError,
+)
 from hyperping.models import (
     AddIncidentUpdateRequest,  # canonical name (M18)
     Incident,
@@ -24,6 +28,14 @@ from hyperping.models import (
 
 logger = logging.getLogger(__name__)
 
+# Incidents attach status pages via the same mechanism as maintenance windows,
+# which the API caps at 51 per request (see MAX_STATUSPAGES_PER_MAINTENANCE):
+# beyond the cap the create is accepted but silently not persisted. The
+# incident cap has NOT been independently verified against the live API; it is
+# assumed identical because the status-page attachment is the same backend
+# path. Adjust if the incident endpoint is later measured to differ.
+MAX_STATUSPAGES_PER_INCIDENT = 51
+
 
 class IncidentsMixin(_ClientProtocol):
     """Incident-related API operations."""
@@ -87,6 +99,15 @@ class IncidentsMixin(_ClientProtocol):
             v3 API returns {"message": "...", "uuid": "..."} on create,
             not the full incident object. The full incident is fetched after creation.
         """
+        n_statuspages = len(incident.statuspages or [])
+        if n_statuspages > MAX_STATUSPAGES_PER_INCIDENT:
+            raise HyperpingValidationError(
+                f"An incident can reference at most {MAX_STATUSPAGES_PER_INCIDENT} "
+                f"status pages, but {n_statuspages} were supplied. Above this limit "
+                f"Hyperping's API is expected to accept the create (returns a uuid) but "
+                f"silently fail to persist it. Use create_incidents() to split the "
+                f"status pages across multiple incidents."
+            )
         payload = incident.model_dump(exclude_none=True, by_alias=True, mode="json")
         response = expect_dict(
             self._request("POST", Endpoint.INCIDENTS, json=payload),
@@ -98,6 +119,49 @@ class IncidentsMixin(_ClientProtocol):
             return self.get_incident(response["uuid"])
         return Incident.model_validate(response)
 
+    def create_incidents(
+        self,
+        incident: IncidentCreate,
+        *,
+        chunk_size: int = MAX_STATUSPAGES_PER_INCIDENT,
+    ) -> list[Incident]:
+        """Create one or more incidents, splitting status pages into chunks.
+
+        Mirrors :meth:`create_maintenance_windows`: a broadcast incident that
+        targets more status pages than the per-request cap is split into
+        consecutive incidents of at most ``chunk_size`` pages. Because the page
+        sets are disjoint, each status page still shows exactly one incident.
+
+        Returns the created incidents in page order (a single incident when the
+        pages fit in one chunk). Raises :class:`HyperpingValidationError` for a
+        bad ``chunk_size`` and :class:`HyperpingPartialBatchError` if a later
+        chunk fails after earlier incidents were already created.
+        """
+        if not 1 <= chunk_size <= MAX_STATUSPAGES_PER_INCIDENT:
+            raise HyperpingValidationError(
+                f"chunk_size must be between 1 and "
+                f"{MAX_STATUSPAGES_PER_INCIDENT}, got {chunk_size}."
+            )
+        pages = list(incident.statuspages or [])
+        if len(pages) <= chunk_size:
+            return [self.create_incident(incident)]
+        chunks = [pages[i : i + chunk_size] for i in range(0, len(pages), chunk_size)]
+        created: list[Incident] = []
+        for idx, chunk_pages in enumerate(chunks):
+            chunk = incident.model_copy(update={"statuspages": chunk_pages})
+            try:
+                created.append(self.create_incident(chunk))
+            except HyperpingAPIError as exc:
+                raise HyperpingPartialBatchError(
+                    f"create_incidents failed on incident {idx + 1} of "
+                    f"{len(chunks)}: {exc}. {len(created)} incident(s) were already "
+                    f"created and remain live.",
+                    created=created,
+                    completed=len(created),
+                    total=len(chunks),
+                ) from exc
+        return created
+
     def update_incident(
         self,
         incident_id: str,

{hyperping-1.8.0 → hyperping-1.9.0}/src/hyperping/_maintenance_mixin.py

@@ -12,12 +12,26 @@ 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,
+    HyperpingPartialBatchError,
+    HyperpingValidationError,
+)
 from hyperping.models import (
     Maintenance,
     MaintenanceCreate,
     MaintenanceUpdate,
 )
 
+# Hyperping's v1 maintenance-windows API silently drops a create when the
+# ``statuspages`` array exceeds this many entries: the POST still returns a
+# ``{"uuid": ...}`` but the window is never persisted (the follow-up GET 404s
+# and it is absent from the list). Empirically the cutoff is 51 (51 persists,
+# 52+ vanishes), verified against the live API on 2026-07-14. Guard the create
+# so callers get a clear error instead of a phantom window; split larger sets
+# across multiple windows.
+MAX_STATUSPAGES_PER_MAINTENANCE = 51
+
 logger = logging.getLogger(__name__)
 
 
@@ -88,6 +102,15 @@ class MaintenanceMixin(_ClientProtocol):
             v1 API returns {"uuid": "..."} on create, not the full maintenance object.
             The full maintenance window is fetched after creation.
         """
+        n_statuspages = len(maintenance.statuspages or [])
+        if n_statuspages > MAX_STATUSPAGES_PER_MAINTENANCE:
+            raise HyperpingValidationError(
+                f"A maintenance window can reference at most "
+                f"{MAX_STATUSPAGES_PER_MAINTENANCE} status pages, but {n_statuspages} "
+                f"were supplied. Above this limit Hyperping's API accepts the create "
+                f"(returns a uuid) but silently fails to persist the window. Split the "
+                f"status pages across multiple maintenance windows."
+            )
         payload = maintenance.model_dump(exclude_none=True, by_alias=True, mode="json")
         response = expect_dict(
             self._request("POST", Endpoint.MAINTENANCE, json=payload),
@@ -99,6 +122,62 @@ class MaintenanceMixin(_ClientProtocol):
             return self.get_maintenance(response["uuid"])
         return Maintenance.model_validate(response)
 
+    def create_maintenance_windows(
+        self,
+        maintenance: MaintenanceCreate,
+        *,
+        chunk_size: int = MAX_STATUSPAGES_PER_MAINTENANCE,
+    ) -> list[Maintenance]:
+        """Create one or more windows, splitting status pages into chunks.
+
+        Hyperping silently fails to persist a window with more than
+        :data:`MAX_STATUSPAGES_PER_MAINTENANCE` status pages (see
+        :meth:`create_maintenance`). This helper splits a large ``statuspages``
+        list into consecutive windows of at most ``chunk_size`` pages so every
+        page is covered. Each window carries the full ``monitors`` set (the API
+        rejects a window with no monitors); overlapping monitor coverage across
+        the windows is harmless.
+
+        Args:
+            maintenance: Creation data; ``statuspages`` may exceed the limit.
+            chunk_size: Max status pages per window (1..
+                :data:`MAX_STATUSPAGES_PER_MAINTENANCE`).
+
+        Returns:
+            The created windows in page order (a single window when the pages
+            fit in one chunk).
+
+        Raises:
+            HyperpingValidationError: If ``chunk_size`` is out of range.
+        """
+        if not 1 <= chunk_size <= MAX_STATUSPAGES_PER_MAINTENANCE:
+            raise HyperpingValidationError(
+                f"chunk_size must be between 1 and "
+                f"{MAX_STATUSPAGES_PER_MAINTENANCE}, got {chunk_size}."
+            )
+        pages = list(maintenance.statuspages or [])
+        if len(pages) <= chunk_size:
+            return [self.create_maintenance(maintenance)]
+        chunks = [pages[i : i + chunk_size] for i in range(0, len(pages), chunk_size)]
+        windows: list[Maintenance] = []
+        for idx, chunk_pages in enumerate(chunks):
+            chunk = maintenance.model_copy(update={"statuspages": chunk_pages})
+            try:
+                windows.append(self.create_maintenance(chunk))
+            except HyperpingAPIError as exc:
+                # Earlier windows are already live and are NOT rolled back; hand
+                # them back so the caller can record or clean them up rather than
+                # orphaning them silently.
+                raise HyperpingPartialBatchError(
+                    f"create_maintenance_windows failed on window {idx + 1} of "
+                    f"{len(chunks)}: {exc}. {len(windows)} window(s) were already "
+                    f"created and remain live.",
+                    created=windows,
+                    completed=len(windows),
+                    total=len(chunks),
+                ) from exc
+        return windows
+
     def update_maintenance(
         self,
         maintenance_id: str,

hyperping-1.9.0/src/hyperping/_version.py

@@ -0,0 +1 @@
+__version__ = "1.9.0"

hyperping-1.9.0/src/hyperping/cli/_app.py

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