watchfor 0.1.0__tar.gz

watchfor-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 WatchFor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

watchfor-0.1.0/PKG-INFO

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: watchfor
+Version: 0.1.0
+Summary: Official Python SDK + CLI for WatchFor — uptime & infrastructure monitoring (monitors, alert rules, incidents, maintenance windows) over the REST API.
+Author-email: WatchFor <hello@watchfor.io>
+License: MIT
+Project-URL: Homepage, https://watchfor.io/docs/api
+Project-URL: Documentation, https://watchfor.io/docs/api
+Project-URL: Source, https://www.npmjs.com/package/watchfor
+Project-URL: Bug Reports, https://watchfor.io/docs/api
+Keywords: watchfor,monitoring,uptime,sdk,cli,incidents,status-page,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# watchfor (Python)
+
+Official Python SDK + CLI for [WatchFor](https://watchfor.io) — uptime &
+infrastructure monitoring (monitors, alert rules, incidents, maintenance
+windows) over the REST API. Zero dependencies (standard library only).
+
+There is also a [TypeScript SDK](https://www.npmjs.com/package/watchfor),
+an [MCP server](https://watchfor.io/docs/api/mcp) and an
+[A2A agent](https://watchfor.io/docs/api/a2a) for AI agents.
+
+## Install
+
+```bash
+pip install watchfor
+```
+
+## Quick start
+
+```python
+from watchfor import WatchFor
+
+wf = WatchFor(api_key="wf_live_...")  # create keys in Settings → API keys
+
+# One-call org snapshot
+print(wf.summary())
+
+# List monitors
+for m in wf.monitors.list()["data"]:
+    print(m["name"], m["status"])
+
+# Create a monitor (idempotency key optional, for safe retries)
+mon = wf.monitors.create(
+    {
+        "name": "example.com",
+        "type": "http",
+        "target": "https://example.com",
+        "interval": 300,
+        "locations": ["<location-id>"],  # from wf.locations()
+    },
+    idempotency_key="create-example-1",
+)
+
+# Diagnose: firing incidents right now
+for inc in wf.incidents.list(status="firing")["data"]:
+    print(inc["message"], inc["severity"])
+```
+
+Resource namespaces: `wf.monitors`, `wf.alert_rules`, `wf.incidents`,
+`wf.maintenance_windows`, `wf.contacts`, `wf.contact_groups`. Top-level:
+`wf.summary()`, `wf.plan()`, `wf.me()`, `wf.locations()`, `wf.monitor_types()`,
+`wf.incident_stats(period=...)`, `wf.notifications(...)`, `wf.activity(...)`.
+
+Errors raise `WatchForError` with `.status`, `.code` and `.message`.
+
+## CLI
+
+```bash
+export WATCHFOR_API_KEY=wf_live_...
+watchfor summary
+watchfor monitors
+watchfor incidents --status firing
+watchfor checks <monitor_id>
+```
+
+## Auth & scopes
+
+Keys carry a scope: `read` (all GET endpoints) or `write` (read plus
+create/update/delete). See
+[authentication](https://watchfor.io/docs/api/authentication). The API is also
+reachable via OAuth 2.1 for MCP clients.
+
+## Reference
+
+- OpenAPI spec: <https://watchfor.io/openapi.json>
+- Guides: <https://watchfor.io/docs/api>
+
+MIT License.

watchfor-0.1.0/README.md

@@ -0,0 +1,77 @@
+# watchfor (Python)
+
+Official Python SDK + CLI for [WatchFor](https://watchfor.io) — uptime &
+infrastructure monitoring (monitors, alert rules, incidents, maintenance
+windows) over the REST API. Zero dependencies (standard library only).
+
+There is also a [TypeScript SDK](https://www.npmjs.com/package/watchfor),
+an [MCP server](https://watchfor.io/docs/api/mcp) and an
+[A2A agent](https://watchfor.io/docs/api/a2a) for AI agents.
+
+## Install
+
+```bash
+pip install watchfor
+```
+
+## Quick start
+
+```python
+from watchfor import WatchFor
+
+wf = WatchFor(api_key="wf_live_...")  # create keys in Settings → API keys
+
+# One-call org snapshot
+print(wf.summary())
+
+# List monitors
+for m in wf.monitors.list()["data"]:
+    print(m["name"], m["status"])
+
+# Create a monitor (idempotency key optional, for safe retries)
+mon = wf.monitors.create(
+    {
+        "name": "example.com",
+        "type": "http",
+        "target": "https://example.com",
+        "interval": 300,
+        "locations": ["<location-id>"],  # from wf.locations()
+    },
+    idempotency_key="create-example-1",
+)
+
+# Diagnose: firing incidents right now
+for inc in wf.incidents.list(status="firing")["data"]:
+    print(inc["message"], inc["severity"])
+```
+
+Resource namespaces: `wf.monitors`, `wf.alert_rules`, `wf.incidents`,
+`wf.maintenance_windows`, `wf.contacts`, `wf.contact_groups`. Top-level:
+`wf.summary()`, `wf.plan()`, `wf.me()`, `wf.locations()`, `wf.monitor_types()`,
+`wf.incident_stats(period=...)`, `wf.notifications(...)`, `wf.activity(...)`.
+
+Errors raise `WatchForError` with `.status`, `.code` and `.message`.
+
+## CLI
+
+```bash
+export WATCHFOR_API_KEY=wf_live_...
+watchfor summary
+watchfor monitors
+watchfor incidents --status firing
+watchfor checks <monitor_id>
+```
+
+## Auth & scopes
+
+Keys carry a scope: `read` (all GET endpoints) or `write` (read plus
+create/update/delete). See
+[authentication](https://watchfor.io/docs/api/authentication). The API is also
+reachable via OAuth 2.1 for MCP clients.
+
+## Reference
+
+- OpenAPI spec: <https://watchfor.io/openapi.json>
+- Guides: <https://watchfor.io/docs/api>
+
+MIT License.

watchfor-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "watchfor"
+version = "0.1.0"
+description = "Official Python SDK + CLI for WatchFor — uptime & infrastructure monitoring (monitors, alert rules, incidents, maintenance windows) over the REST API."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "WatchFor", email = "hello@watchfor.io" }]
+keywords = [
+    "watchfor",
+    "monitoring",
+    "uptime",
+    "sdk",
+    "cli",
+    "incidents",
+    "status-page",
+    "mcp",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: System :: Monitoring",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://watchfor.io/docs/api"
+Documentation = "https://watchfor.io/docs/api"
+"Source" = "https://www.npmjs.com/package/watchfor"
+"Bug Reports" = "https://watchfor.io/docs/api"
+
+[project.scripts]
+watchfor = "watchfor.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["watchfor*"]

watchfor-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

watchfor-0.1.0/watchfor/__init__.py

@@ -0,0 +1,9 @@
+"""Official Python SDK + CLI for WatchFor — uptime & infrastructure monitoring.
+
+See https://watchfor.io/docs/api for guides and the OpenAPI spec.
+"""
+
+from ._version import __version__
+from .client import DEFAULT_BASE_URL, WatchFor, WatchForError
+
+__all__ = ["WatchFor", "WatchForError", "DEFAULT_BASE_URL", "__version__"]

watchfor-0.1.0/watchfor/_version.py

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

watchfor-0.1.0/watchfor/cli.py

@@ -0,0 +1,90 @@
+"""`watchfor` command-line interface — a thin wrapper over the SDK.
+
+Reads the API key from ``--api-key`` or the ``WATCHFOR_API_KEY`` env var::
+
+    export WATCHFOR_API_KEY=wf_live_...
+    watchfor summary
+    watchfor monitors
+    watchfor incidents --status firing
+    watchfor checks <monitor_id>
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+
+from ._version import __version__
+from .client import WatchFor, WatchForError
+
+
+def _print(obj: object) -> None:
+    print(json.dumps(obj, indent=2, ensure_ascii=False))
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="watchfor",
+        description="WatchFor uptime & infrastructure monitoring — CLI.",
+    )
+    parser.add_argument("--version", action="version", version=f"watchfor {__version__}")
+    parser.add_argument(
+        "--api-key",
+        default=os.environ.get("WATCHFOR_API_KEY"),
+        help="API key (or set WATCHFOR_API_KEY).",
+    )
+    parser.add_argument(
+        "--base-url",
+        default=os.environ.get("WATCHFOR_BASE_URL", "https://watchfor.io/api/v1"),
+        help="API base URL.",
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    sub.add_parser("summary", help="Org snapshot: status counts + active incidents.")
+    sub.add_parser("plan", help="Current plan, limits and usage.")
+    sub.add_parser("monitors", help="List monitors.")
+    sub.add_parser("locations", help="List probe locations.")
+    sub.add_parser("monitor-types", help="Catalog of monitor types.")
+
+    p_inc = sub.add_parser("incidents", help="List incidents.")
+    p_inc.add_argument("--status", choices=["firing", "acknowledged", "resolved"])
+    p_inc.add_argument("--limit", type=int)
+
+    p_checks = sub.add_parser("checks", help="Recent checks for a monitor.")
+    p_checks.add_argument("monitor_id")
+    p_checks.add_argument("--limit", type=int)
+
+    args = parser.parse_args(argv)
+
+    if not args.api_key:
+        parser.error("No API key. Pass --api-key or set WATCHFOR_API_KEY.")
+
+    wf = WatchFor(api_key=args.api_key, base_url=args.base_url)
+
+    try:
+        if args.command == "summary":
+            _print(wf.summary())
+        elif args.command == "plan":
+            _print(wf.plan())
+        elif args.command == "monitors":
+            _print(wf.monitors.list())
+        elif args.command == "locations":
+            _print(wf.locations())
+        elif args.command == "monitor-types":
+            _print(wf.monitor_types())
+        elif args.command == "incidents":
+            _print(wf.incidents.list(status=args.status, limit=args.limit))
+        elif args.command == "checks":
+            _print(wf.monitors.checks(args.monitor_id, limit=args.limit))
+        else:  # pragma: no cover - argparse enforces choices
+            parser.error(f"Unknown command: {args.command}")
+    except WatchForError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

watchfor-0.1.0/watchfor/client.py

@@ -0,0 +1,293 @@
+"""WatchFor REST API client (zero-dependency, stdlib only).
+
+Usage::
+
+    from watchfor import WatchFor
+
+    wf = WatchFor(api_key="wf_live_...")
+    print(wf.summary())
+    for m in wf.monitors.list()["data"]:
+        print(m["name"], m["status"])
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Optional
+
+from ._version import __version__
+
+DEFAULT_BASE_URL = "https://watchfor.io/api/v1"
+
+JsonDict = dict[str, Any]
+
+
+class WatchForError(Exception):
+    """Raised when the API returns a non-2xx response.
+
+    Carries the HTTP ``status`` and the API's structured ``code`` and
+    ``message`` (WatchFor errors are always ``{"error":{"code","message"}}``).
+    """
+
+    def __init__(self, status: int, code: str, message: str):
+        super().__init__(f"[{status}] {code}: {message}")
+        self.status = status
+        self.code = code
+        self.message = message
+
+
+def _clean_query(query: Optional[dict[str, Any]]) -> dict[str, str]:
+    if not query:
+        return {}
+    out: dict[str, str] = {}
+    for k, v in query.items():
+        if v is None or v == "":
+            continue
+        out[k] = str(v).lower() if isinstance(v, bool) else str(v)
+    return out
+
+
+class WatchFor:
+    """Client for the WatchFor REST API (``/api/v1``).
+
+    :param api_key: A ``wf_live_...`` key created in Settings -> API keys.
+    :param base_url: Override the API base (e.g. for a self-hosted instance).
+    :param timeout: Per-request timeout in seconds.
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+    ):
+        if not api_key:
+            raise ValueError("api_key is required")
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        # Resource namespaces (mirror the TypeScript SDK).
+        self.monitors = _Monitors(self)
+        self.alert_rules = _AlertRules(self)
+        self.incidents = _Incidents(self)
+        self.maintenance_windows = _MaintenanceWindows(self)
+        self.contacts = _Contacts(self)
+        self.contact_groups = _ContactGroups(self)
+
+    # ── core request ────────────────────────────────────────────────
+    def request(
+        self,
+        method: str,
+        path: str,
+        query: Optional[dict[str, Any]] = None,
+        body: Optional[Any] = None,
+        idempotency_key: Optional[str] = None,
+    ) -> Any:
+        url = self.base_url + path
+        q = _clean_query(query)
+        if q:
+            url += "?" + urllib.parse.urlencode(q)
+        data = None
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Accept": "application/json",
+            "User-Agent": f"watchfor-python/{__version__}",
+        }
+        if body is not None:
+            data = json.dumps(body).encode("utf-8")
+            headers["Content-Type"] = "application/json"
+        if idempotency_key:
+            headers["Idempotency-Key"] = idempotency_key
+
+        req = urllib.request.Request(url, data=data, headers=headers, method=method)
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                raw = resp.read()
+                if not raw:
+                    return {"ok": True, "status": resp.status}
+                return json.loads(raw)
+        except urllib.error.HTTPError as exc:  # noqa: PERF203
+            raw = exc.read()
+            code, message = "http_error", f"HTTP {exc.code}"
+            try:
+                parsed = json.loads(raw)
+                err = parsed.get("error", {})
+                code = err.get("code", code)
+                message = err.get("message", message)
+            except Exception:  # noqa: BLE001
+                if raw:
+                    message = raw.decode("utf-8", "replace")[:200]
+            raise WatchForError(exc.code, code, message) from None
+
+    # ── top-level reads ─────────────────────────────────────────────
+    def me(self) -> Any:
+        """The authenticated key's identity and organization."""
+        return self.request("GET", "/me")
+
+    def summary(self) -> Any:
+        """One-call org snapshot: monitor status counts + active incidents."""
+        return self.request("GET", "/summary")
+
+    def plan(self) -> Any:
+        """Current plan, its limits and usage."""
+        return self.request("GET", "/plan")
+
+    def incident_stats(self, period: Optional[str] = None) -> Any:
+        """Aggregate incident stats (period: 24h / 7d / 30d / 90d)."""
+        return self.request("GET", "/incidents/stats", query={"period": period})
+
+    def locations(self) -> Any:
+        """Probe locations a monitor can run from."""
+        return self.request("GET", "/locations")
+
+    def monitor_types(self) -> Any:
+        """Catalog of every monitor type: target format, config, alert metrics."""
+        return self.request("GET", "/meta/monitor-types")
+
+    def notifications(self, **query: Any) -> Any:
+        """Alert-notification delivery history."""
+        return self.request("GET", "/notifications", query=query)
+
+    def activity(self, **query: Any) -> Any:
+        """Organization audit trail."""
+        return self.request("GET", "/activity", query=query)
+
+
+class _Namespace:
+    def __init__(self, client: WatchFor):
+        self._c = client
+
+
+class _Monitors(_Namespace):
+    def list(self, **query: Any) -> Any:
+        return self._c.request("GET", "/monitors", query=query)
+
+    def get(self, monitor_id: str) -> Any:
+        return self._c.request("GET", f"/monitors/{monitor_id}")
+
+    def create(self, body: JsonDict, idempotency_key: Optional[str] = None) -> Any:
+        return self._c.request(
+            "POST", "/monitors", body=body, idempotency_key=idempotency_key
+        )
+
+    def update(self, monitor_id: str, body: JsonDict) -> Any:
+        return self._c.request("PATCH", f"/monitors/{monitor_id}", body=body)
+
+    def delete(self, monitor_id: str) -> Any:
+        return self._c.request("DELETE", f"/monitors/{monitor_id}")
+
+    def pause(self, monitor_id: str) -> Any:
+        return self._c.request("POST", f"/monitors/{monitor_id}/pause")
+
+    def resume(self, monitor_id: str) -> Any:
+        return self._c.request("POST", f"/monitors/{monitor_id}/resume")
+
+    def check_now(self, monitor_id: str) -> Any:
+        return self._c.request("POST", f"/monitors/{monitor_id}/check-now")
+
+    def uptime(self, monitor_id: str, period: Optional[str] = None) -> Any:
+        return self._c.request(
+            "GET", f"/monitors/{monitor_id}/uptime", query={"period": period}
+        )
+
+    def checks(self, monitor_id: str, **query: Any) -> Any:
+        return self._c.request("GET", f"/monitors/{monitor_id}/checks", query=query)
+
+
+class _AlertRules(_Namespace):
+    def list(self, monitor_id: str) -> Any:
+        return self._c.request("GET", f"/monitors/{monitor_id}/alert-rules")
+
+    def get(self, monitor_id: str, rule_id: str) -> Any:
+        return self._c.request(
+            "GET", f"/monitors/{monitor_id}/alert-rules/{rule_id}"
+        )
+
+    def create(self, monitor_id: str, body: JsonDict) -> Any:
+        return self._c.request(
+            "POST", f"/monitors/{monitor_id}/alert-rules", body=body
+        )
+
+    def update(self, monitor_id: str, rule_id: str, body: JsonDict) -> Any:
+        return self._c.request(
+            "PATCH", f"/monitors/{monitor_id}/alert-rules/{rule_id}", body=body
+        )
+
+    def delete(self, monitor_id: str, rule_id: str) -> Any:
+        return self._c.request(
+            "DELETE", f"/monitors/{monitor_id}/alert-rules/{rule_id}"
+        )
+
+
+class _Incidents(_Namespace):
+    def list(self, **query: Any) -> Any:
+        return self._c.request("GET", "/incidents", query=query)
+
+    def get(self, incident_id: int | str) -> Any:
+        return self._c.request("GET", f"/incidents/{incident_id}")
+
+    def acknowledge(self, incident_id: int | str) -> Any:
+        return self._c.request("POST", f"/incidents/{incident_id}/acknowledge")
+
+    def resolve(self, incident_id: int | str) -> Any:
+        return self._c.request("POST", f"/incidents/{incident_id}/resolve")
+
+
+class _MaintenanceWindows(_Namespace):
+    def list(self, **query: Any) -> Any:
+        return self._c.request("GET", "/maintenance-windows", query=query)
+
+    def get(self, window_id: str) -> Any:
+        return self._c.request("GET", f"/maintenance-windows/{window_id}")
+
+    def create(self, body: JsonDict, idempotency_key: Optional[str] = None) -> Any:
+        return self._c.request(
+            "POST", "/maintenance-windows", body=body, idempotency_key=idempotency_key
+        )
+
+    def update(self, window_id: str, body: JsonDict) -> Any:
+        return self._c.request("PATCH", f"/maintenance-windows/{window_id}", body=body)
+
+    def delete(self, window_id: str) -> Any:
+        return self._c.request("DELETE", f"/maintenance-windows/{window_id}")
+
+
+class _Contacts(_Namespace):
+    def list(self, **query: Any) -> Any:
+        return self._c.request("GET", "/contacts", query=query)
+
+    def get(self, contact_id: str) -> Any:
+        return self._c.request("GET", f"/contacts/{contact_id}")
+
+    def create(self, body: JsonDict, idempotency_key: Optional[str] = None) -> Any:
+        return self._c.request(
+            "POST", "/contacts", body=body, idempotency_key=idempotency_key
+        )
+
+    def update(self, contact_id: str, body: JsonDict) -> Any:
+        return self._c.request("PATCH", f"/contacts/{contact_id}", body=body)
+
+    def delete(self, contact_id: str) -> Any:
+        return self._c.request("DELETE", f"/contacts/{contact_id}")
+
+
+class _ContactGroups(_Namespace):
+    def list(self, **query: Any) -> Any:
+        return self._c.request("GET", "/contact-groups", query=query)
+
+    def get(self, group_id: str) -> Any:
+        return self._c.request("GET", f"/contact-groups/{group_id}")
+
+    def create(self, body: JsonDict, idempotency_key: Optional[str] = None) -> Any:
+        return self._c.request(
+            "POST", "/contact-groups", body=body, idempotency_key=idempotency_key
+        )
+
+    def update(self, group_id: str, body: JsonDict) -> Any:
+        return self._c.request("PATCH", f"/contact-groups/{group_id}", body=body)
+
+    def delete(self, group_id: str) -> Any:
+        return self._c.request("DELETE", f"/contact-groups/{group_id}")

watchfor-0.1.0/watchfor.egg-info/PKG-INFO

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: watchfor
+Version: 0.1.0
+Summary: Official Python SDK + CLI for WatchFor — uptime & infrastructure monitoring (monitors, alert rules, incidents, maintenance windows) over the REST API.
+Author-email: WatchFor <hello@watchfor.io>
+License: MIT
+Project-URL: Homepage, https://watchfor.io/docs/api
+Project-URL: Documentation, https://watchfor.io/docs/api
+Project-URL: Source, https://www.npmjs.com/package/watchfor
+Project-URL: Bug Reports, https://watchfor.io/docs/api
+Keywords: watchfor,monitoring,uptime,sdk,cli,incidents,status-page,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# watchfor (Python)
+
+Official Python SDK + CLI for [WatchFor](https://watchfor.io) — uptime &
+infrastructure monitoring (monitors, alert rules, incidents, maintenance
+windows) over the REST API. Zero dependencies (standard library only).
+
+There is also a [TypeScript SDK](https://www.npmjs.com/package/watchfor),
+an [MCP server](https://watchfor.io/docs/api/mcp) and an
+[A2A agent](https://watchfor.io/docs/api/a2a) for AI agents.
+
+## Install
+
+```bash
+pip install watchfor
+```
+
+## Quick start
+
+```python
+from watchfor import WatchFor
+
+wf = WatchFor(api_key="wf_live_...")  # create keys in Settings → API keys
+
+# One-call org snapshot
+print(wf.summary())
+
+# List monitors
+for m in wf.monitors.list()["data"]:
+    print(m["name"], m["status"])
+
+# Create a monitor (idempotency key optional, for safe retries)
+mon = wf.monitors.create(
+    {
+        "name": "example.com",
+        "type": "http",
+        "target": "https://example.com",
+        "interval": 300,
+        "locations": ["<location-id>"],  # from wf.locations()
+    },
+    idempotency_key="create-example-1",
+)
+
+# Diagnose: firing incidents right now
+for inc in wf.incidents.list(status="firing")["data"]:
+    print(inc["message"], inc["severity"])
+```
+
+Resource namespaces: `wf.monitors`, `wf.alert_rules`, `wf.incidents`,
+`wf.maintenance_windows`, `wf.contacts`, `wf.contact_groups`. Top-level:
+`wf.summary()`, `wf.plan()`, `wf.me()`, `wf.locations()`, `wf.monitor_types()`,
+`wf.incident_stats(period=...)`, `wf.notifications(...)`, `wf.activity(...)`.
+
+Errors raise `WatchForError` with `.status`, `.code` and `.message`.
+
+## CLI
+
+```bash
+export WATCHFOR_API_KEY=wf_live_...
+watchfor summary
+watchfor monitors
+watchfor incidents --status firing
+watchfor checks <monitor_id>
+```
+
+## Auth & scopes
+
+Keys carry a scope: `read` (all GET endpoints) or `write` (read plus
+create/update/delete). See
+[authentication](https://watchfor.io/docs/api/authentication). The API is also
+reachable via OAuth 2.1 for MCP clients.
+
+## Reference
+
+- OpenAPI spec: <https://watchfor.io/openapi.json>
+- Guides: <https://watchfor.io/docs/api>
+
+MIT License.

watchfor-0.1.0/watchfor.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+watchfor/__init__.py
+watchfor/_version.py
+watchfor/cli.py
+watchfor/client.py
+watchfor.egg-info/PKG-INFO
+watchfor.egg-info/SOURCES.txt
+watchfor.egg-info/dependency_links.txt
+watchfor.egg-info/entry_points.txt
+watchfor.egg-info/top_level.txt

watchfor-0.1.0/watchfor.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

watchfor-0.1.0/watchfor.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+watchfor = watchfor.cli:main

watchfor-0.1.0/watchfor.egg-info/top_level.txt

@@ -0,0 +1 @@
+watchfor