syschecks 0.1.0a1__tar.gz

syschecks-0.1.0a1/.github/workflows/release.yml

@@ -0,0 +1,67 @@
+name: release
+
+# Cut a release by pushing a semver tag, e.g.:
+#   git tag v0.1.0a1 && git push origin v0.1.0a1
+#
+# Publishing uses PyPI Trusted Publishing (OIDC) — no API token/secret needed.
+# One-time PyPI setup (https://pypi.org/manage/account/publishing/):
+#   Add a "pending publisher" for project `syschecks`:
+#     Owner: systeampl | Repo: syschecks-python
+#     Workflow: release.yml | Environment: pypi
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      # Stamp the tag into pyproject so the artifact version == the git tag.
+      - name: Stamp version from tag
+        run: |
+          VERSION="${GITHUB_REF_NAME#v}"
+          sed -i "s/^version = \".*\"\$/version = \"${VERSION}\"/" pyproject.toml
+          grep -n '^version' pyproject.toml
+
+      - name: Build sdist + wheel
+        run: |
+          python -m pip install --upgrade build
+          python -m build
+
+      # Install the freshly built wheel and run the structural smoke tests
+      # against it — never publish a wheel we haven't imported.
+      - name: Test the built wheel
+        run: |
+          python -m pip install "$(ls dist/*.whl)" pytest
+          python -m pytest tests/ -q
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write   # OIDC token for Trusted Publishing
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

syschecks-0.1.0a1/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+build/
+dist/
+.venv/
+venv/
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/

syschecks-0.1.0a1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SysTeam
+
+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.

syschecks-0.1.0a1/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: syschecks
+Version: 0.1.0a1
+Summary: Official Python SDK for the Syschecks API
+Project-URL: Homepage, https://syschecks.com
+Project-URL: Source, https://github.com/systeampl/syschecks-python
+Author: SysTeam
+License-Expression: MIT
+License-File: LICENSE
+Keywords: healthchecks,monitoring,oncall,sdk,syschecks
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: attrs>=22.2.0
+Requires-Dist: httpx<0.29,>=0.23
+Requires-Dist: python-dateutil>=2.8.0
+Description-Content-Type: text/markdown
+
+# syschecks — Python SDK
+
+Official Python client for the [Syschecks](https://syschecks.com) API — monitoring,
+incidents, on-call, status pages, playbooks and more.
+
+```bash
+pip install syschecks
+```
+
+## Usage
+
+```python
+from syschecks import SyschecksClient
+from syschecks.models import CheckCreate
+
+sc = SyschecksClient(base_url="https://api.syschecks.com", token="sk_...")
+
+# fluent, typed, autocompleted — one client, resource namespaces
+checks = sc.checks.list_checks()
+check = sc.checks.create_new_check(body=CheckCreate(name="api-prod", ...))
+sc.incidents.list_incidents()
+sc.oncall.get_schedule(schedule_id=3)
+sc.playbooks.create_playbook(org_id=1, body=...)
+```
+
+Every endpoint is a method on its resource namespace (`sc.<resource>.<operation>()`),
+mirroring Stripe / Anthropic-style SDKs. Path parameters are positional, request
+bodies and query filters are keyword arguments — all fully typed.
+
+## Architecture
+
+This SDK is **generated** from the curated OpenAPI spec (the source of truth):
+
+- `syschecks/_sdk/` — typed HTTP core + models, produced by
+  [`openapi-python-client`](https://github.com/openapi-generators/openapi-python-client).
+- `syschecks/resources/` — the fluent facade (`Checks`, `Incidents`, …), generated
+  by `scripts/gen_facade.py`, each method delegating to the core with `client` injected.
+- `syschecks/client.py` — `SyschecksClient`, wiring the namespaces together.
+
+Nothing under `syschecks/` is hand-edited. Regenerate after a spec change:
+
+```bash
+./scripts/generate.sh            # uses ../syschecks-openapi/syschecks-openapi.json
+./scripts/generate.sh path/to/spec.json
+```
+
+## Known gaps
+
+- **SSE streams** (`events.event_stream`, `sse_metrics`, `sse_stats`) are omitted —
+  streaming is out of scope for v1.
+- A handful of endpoints whose backend routes lack a `response_model` return a raw
+  `Response[Any]` (e.g. `cloud_status.list_cloud_statuses`, `checks.get_slo_summary`)
+  until the backend annotates them.
+
+## Development
+
+```bash
+python -m pytest tests/       # structural smoke tests (no network)
+```

syschecks-0.1.0a1/README.md

@@ -0,0 +1,59 @@
+# syschecks — Python SDK
+
+Official Python client for the [Syschecks](https://syschecks.com) API — monitoring,
+incidents, on-call, status pages, playbooks and more.
+
+```bash
+pip install syschecks
+```
+
+## Usage
+
+```python
+from syschecks import SyschecksClient
+from syschecks.models import CheckCreate
+
+sc = SyschecksClient(base_url="https://api.syschecks.com", token="sk_...")
+
+# fluent, typed, autocompleted — one client, resource namespaces
+checks = sc.checks.list_checks()
+check = sc.checks.create_new_check(body=CheckCreate(name="api-prod", ...))
+sc.incidents.list_incidents()
+sc.oncall.get_schedule(schedule_id=3)
+sc.playbooks.create_playbook(org_id=1, body=...)
+```
+
+Every endpoint is a method on its resource namespace (`sc.<resource>.<operation>()`),
+mirroring Stripe / Anthropic-style SDKs. Path parameters are positional, request
+bodies and query filters are keyword arguments — all fully typed.
+
+## Architecture
+
+This SDK is **generated** from the curated OpenAPI spec (the source of truth):
+
+- `syschecks/_sdk/` — typed HTTP core + models, produced by
+  [`openapi-python-client`](https://github.com/openapi-generators/openapi-python-client).
+- `syschecks/resources/` — the fluent facade (`Checks`, `Incidents`, …), generated
+  by `scripts/gen_facade.py`, each method delegating to the core with `client` injected.
+- `syschecks/client.py` — `SyschecksClient`, wiring the namespaces together.
+
+Nothing under `syschecks/` is hand-edited. Regenerate after a spec change:
+
+```bash
+./scripts/generate.sh            # uses ../syschecks-openapi/syschecks-openapi.json
+./scripts/generate.sh path/to/spec.json
+```
+
+## Known gaps
+
+- **SSE streams** (`events.event_stream`, `sse_metrics`, `sse_stats`) are omitted —
+  streaming is out of scope for v1.
+- A handful of endpoints whose backend routes lack a `response_model` return a raw
+  `Response[Any]` (e.g. `cloud_status.list_cloud_statuses`, `checks.get_slo_summary`)
+  until the backend annotates them.
+
+## Development
+
+```bash
+python -m pytest tests/       # structural smoke tests (no network)
+```

syschecks-0.1.0a1/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "syschecks"
+version = "0.1.0a1"
+description = "Official Python SDK for the Syschecks API"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [{ name = "SysTeam" }]
+keywords = ["syschecks", "monitoring", "healthchecks", "oncall", "sdk"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Typing :: Typed",
+]
+dependencies = [
+    "httpx>=0.23,<0.29",
+    "attrs>=22.2.0",
+    "python-dateutil>=2.8.0",
+]
+
+[project.urls]
+Homepage = "https://syschecks.com"
+Source = "https://github.com/systeampl/syschecks-python"
+
+[tool.hatch.build.targets.wheel]
+packages = ["syschecks"]

syschecks-0.1.0a1/scripts/gen_facade.py

@@ -0,0 +1,245 @@
+#!/usr/bin/env python3
+"""Generate the fluent resource facade over the openapi-python-client core.
+
+The core (``syschecks/_sdk``) exposes one module per endpoint with functional
+``sync``/``asyncio`` helpers that all take ``client=`` explicitly. That is a
+solid typed foundation but not a product-grade SDK surface. This script emits a
+Stripe/Anthropic-style facade so clients write::
+
+    syschecks = SyschecksClient(base_url=..., token=...)
+    syschecks.checks.list_checks()
+    syschecks.checks.create_new_check(body=CheckCreate(...))
+
+For every endpoint we render a REAL typed signature (copied faithfully from the
+generated ``sync`` function, minus ``client``) so editors keep full autocomplete
+and type-checking -- no ``*args, **kwargs`` shortcut.
+"""
+import importlib
+import inspect
+import keyword
+import re
+import sys
+import types as pytypes
+import typing
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+PKG = ROOT / "syschecks"
+API = PKG / "_sdk" / "api"
+
+sys.path.insert(0, str(ROOT))
+from syschecks._sdk.types import Unset  # noqa: E402
+
+
+def pascal(tag: str) -> str:
+    return "".join(p.capitalize() for p in re.split(r"[_\-]+", tag)) or "Default"
+
+
+def render_annotation(ann, imports: set) -> str:
+    """Render a runtime annotation object back into valid source text,
+    recording every non-builtin name that must be imported."""
+    if ann is inspect.Signature.empty:
+        return ""
+    if ann is type(None):
+        return "None"
+    if ann is typing.Any:
+        imports.add(("typing", "Any"))
+        return "Any"
+
+    origin = typing.get_origin(ann)
+    if origin is typing.Union or origin is getattr(pytypes, "UnionType", ()):
+        parts, has_none = [], False
+        for arg in typing.get_args(ann):
+            if arg is type(None):
+                has_none = True
+                continue
+            parts.append(render_annotation(arg, imports))
+        # de-dup while preserving order, None last (Optional-style)
+        seen, uniq = set(), []
+        for p in parts:
+            if p not in seen:
+                seen.add(p)
+                uniq.append(p)
+        if has_none:
+            uniq.append("None")
+        return " | ".join(uniq)
+
+    if origin in (list, typing.List):
+        (inner,) = typing.get_args(ann) or (typing.Any,)
+        return f"list[{render_annotation(inner, imports)}]"
+    if origin in (dict, typing.Dict):
+        args = typing.get_args(ann) or (typing.Any, typing.Any)
+        k, v = (render_annotation(a, imports) for a in args)
+        return f"dict[{k}, {v}]"
+
+    if isinstance(ann, type):
+        mod, name = ann.__module__, ann.__name__
+        if mod == "builtins":
+            return name
+        imports.add((mod, name))
+        return name
+
+    # Fallback: stringify and hope it's a bare name we can import from typing.
+    return str(ann)
+
+
+def render_default(default, imports: set) -> str:
+    if default is inspect.Signature.empty:
+        return ""
+    if isinstance(default, Unset):
+        imports.add(("syschecks._sdk.types", "UNSET"))
+        return "UNSET"
+    if default is None or isinstance(default, (bool, int, float, str)):
+        return repr(default)
+    # Unknown sentinel/object -> safest is UNSET (never a real caller value).
+    imports.add(("syschecks._sdk.types", "UNSET"))
+    return "UNSET"
+
+
+def build_method(op: str, fn, imports: set, call: str) -> str:
+    sig = inspect.signature(fn)
+    positional, kwonly, forward = [], [], []
+    for pname, p in sig.parameters.items():
+        if pname == "client":
+            continue
+        ann = render_annotation(p.annotation, imports)
+        default = render_default(p.default, imports)
+        piece = pname
+        if ann:
+            piece += f": {ann}"
+        if default:
+            piece += f" = {default}"
+        if p.kind == inspect.Parameter.KEYWORD_ONLY:
+            kwonly.append(piece)
+        else:
+            positional.append(piece)
+        forward.append(f"{pname}={pname}")
+
+    ret = render_annotation(sig.return_annotation, imports)
+    params = ["self"] + positional + (["*"] + kwonly if kwonly else [])
+    ret_hint = f" -> {ret}" if ret else ""
+    call_args = ", ".join(["client=self._client"] + forward)
+    body_ret = f"        return _{op}.{call}({call_args})"
+    return (
+        f"    def {op}(" + ", ".join(params) + f"){ret_hint}:\n"
+        f"{body_ret}\n"
+    )
+
+
+def gen_group(tag: str) -> tuple[str, str]:
+    """Return (class_name, source) for one resource group."""
+    grp_mod = importlib.import_module(f"syschecks._sdk.api.{tag}")
+    # endpoint modules = every .py file in the group dir (except __init__)
+    op_names = sorted(
+        f.stem
+        for f in (API / tag).glob("*.py")
+        if f.stem != "__init__"
+    )
+    imports: set = set()
+    methods, op_imports = [], []
+    for op in op_names:
+        if op in SSE_SKIP:
+            SKIPPED.append(f"{tag}.{op} (SSE stream)")
+            continue
+        mod = importlib.import_module(f"syschecks._sdk.api.{tag}.{op}")
+        # Prefer the typed `sync`; fall back to `sync_detailed` (Response[Any])
+        # for endpoints whose backend route has no response_model yet.
+        fn, call = getattr(mod, "sync", None), "sync"
+        if fn is None:
+            fn, call = getattr(mod, "sync_detailed", None), "sync_detailed"
+        if fn is None:
+            SKIPPED.append(f"{tag}.{op} (no sync/sync_detailed)")
+            continue
+        op_imports.append(f"from .._sdk.api.{tag} import {op} as _{op}")
+        methods.append(build_method(op, fn, imports, call))
+
+    cls = pascal(tag)
+    import_lines = "\n".join(
+        f"from {m} import {n}" for m, n in sorted(imports)
+    )
+    header = (
+        '"""Auto-generated resource facade. Do not edit by hand."""\n'
+        "from __future__ import annotations\n\n"
+        + import_lines + ("\n" if import_lines else "")
+        + "\n".join(op_imports) + "\n\n\n"
+    )
+    body = (
+        f"class {cls}:\n"
+        f"    def __init__(self, client) -> None:\n"
+        f"        self._client = client\n\n"
+        + "\n".join(methods)
+    )
+    return cls, header + body
+
+
+SKIP_GROUPS = {"__pycache__", "default"}  # default = API root only, not a resource
+SSE_SKIP = {"event_stream", "sse_metrics", "sse_stats"}  # streaming, not v1 SDK
+SKIPPED: list = []  # audit trail of intentionally-omitted endpoints
+
+
+def main() -> None:
+    tags = sorted(
+        d.name
+        for d in API.iterdir()
+        if d.is_dir() and d.name not in SKIP_GROUPS and (d / "__init__.py").exists()
+    )
+    resources_dir = PKG / "resources"
+    resources_dir.mkdir(exist_ok=True)
+    (resources_dir / "__init__.py").write_text("")
+
+    registry = []  # (tag, class_name)
+    for tag in tags:
+        cls, src = gen_group(tag)
+        (resources_dir / f"{tag}.py").write_text(src)
+        registry.append((tag, cls))
+
+    # client.py -- the fluent root
+    client_imports = "\n".join(
+        f"from .resources.{tag} import {cls}" for tag, cls in registry
+    )
+    attrs = "\n".join(
+        f"        self.{tag} = {cls}(self._client)" for tag, cls in registry
+    )
+    client_src = f'''"""Auto-generated. Do not edit by hand."""
+from __future__ import annotations
+
+from ._sdk.client import AuthenticatedClient
+{client_imports}
+
+
+class SyschecksClient:
+    """Fluent client for the Syschecks API.
+
+    Example::
+
+        sc = SyschecksClient(base_url="https://api.syschecks.com", token="...")
+        sc.checks.list_checks()
+    """
+
+    def __init__(self, *, base_url: str, token: str, **kwargs) -> None:
+        self._client = AuthenticatedClient(base_url=base_url, token=token, **kwargs)
+{attrs}
+'''
+    (PKG / "client.py").write_text(client_src)
+
+    init_src = '''"""Syschecks Python SDK."""
+from .client import SyschecksClient
+
+__all__ = ["SyschecksClient"]
+'''
+    (PKG / "__init__.py").write_text(init_src)
+
+    # PEP 561 marker so consumers' type checkers see our annotations.
+    (PKG / "py.typed").write_text("")
+
+    print(f"facade: {len(registry)} resource groups")
+    for tag, cls in registry:
+        print(f"  {tag:24} -> sc.{tag} ({cls})")
+    if SKIPPED:
+        print(f"\nintentionally omitted ({len(SKIPPED)}):")
+        for s in SKIPPED:
+            print(f"  - {s}")
+
+
+if __name__ == "__main__":
+    main()

syschecks-0.1.0a1/scripts/generate.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+# Regenerate the Syschecks Python SDK from the curated OpenAPI spec.
+#
+#   1. openapi-python-client -> syschecks/_sdk   (typed HTTP core + models)
+#   2. gen_facade.py         -> syschecks/resources/, client.py, __init__.py
+#
+# The spec itself is the source of truth and lives in syschecks-openapi.
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+SPEC="${1:-$ROOT/../syschecks-openapi/syschecks-openapi.json}"
+
+if [[ ! -f "$SPEC" ]]; then
+    echo "spec not found: $SPEC" >&2
+    exit 1
+fi
+
+echo ">> core: openapi-python-client -> syschecks/_sdk"
+rm -rf "$ROOT/syschecks/_sdk"
+( cd "$ROOT/syschecks" && \
+  openapi-python-client generate \
+    --path "$SPEC" \
+    --config "$ROOT/scripts/opc-config.yaml" \
+    --meta none --overwrite )
+
+echo ">> facade: gen_facade.py -> syschecks/resources"
+python3 "$ROOT/scripts/gen_facade.py"
+
+echo ">> done"

syschecks-0.1.0a1/scripts/opc-config.yaml

@@ -0,0 +1,3 @@
+package_name_override: _sdk
+project_name_override: syschecks
+use_path_prefixes_for_title_model_names: false

syschecks-0.1.0a1/syschecks/__init__.py

@@ -0,0 +1,4 @@
+"""Syschecks Python SDK."""
+from .client import SyschecksClient
+
+__all__ = ["SyschecksClient"]

syschecks-0.1.0a1/syschecks/_sdk/__init__.py

@@ -0,0 +1,8 @@
+"""A client library for accessing Syschecks API"""
+
+from .client import AuthenticatedClient, Client
+
+__all__ = (
+    "AuthenticatedClient",
+    "Client",
+)

syschecks-0.1.0a1/syschecks/_sdk/api/__init__.py

@@ -0,0 +1 @@
+"""Contains methods for accessing the API"""

syschecks-0.1.0a1/syschecks/_sdk/api/action_items/__init__.py

@@ -0,0 +1 @@
+"""Contains endpoint functions for accessing the API"""