wayscloud 0.2.3__tar.gz → 0.4.0__tar.gz

{wayscloud-0.2.3 → wayscloud-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wayscloud
-Version: 0.2.3
+Version: 0.4.0
 Summary: Official Python SDK for the WAYSCloud API
 Home-page: https://wayscloud.services
 License: MIT
@@ -76,6 +76,68 @@ client.storage.create_bucket("my-bucket")
 client.sms.send(to="+4712345678", message="Hello from WAYSCloud")
 ```
 
+## Kubernetes
+
+`client.kubernetes` manages Managed Kubernetes clusters (PAT scopes
+`kubernetes:read` / `kubernetes:write`). Create and delete are asynchronous:
+the API answers `202` with status `provisioning` / `deleting`, and `wait()`
+blocks until the cluster is `running`, `error`, or gone.
+
+```python
+# Catalogue
+client.kubernetes.plans(region="no", kind="node")
+client.kubernetes.regions()
+client.kubernetes.versions()
+client.kubernetes.estimate(
+    plan_code="k8s-cluster-dev",
+    node_pools=[{"name": "default", "plan_code": "k8s-node-2c4g", "count": 2}],
+)
+
+# Clusters
+cluster = client.kubernetes.create(
+    "shop",
+    node_pools=[{"name": "default", "plan_code": "k8s-node-2c4g", "count": 2}],
+    ssh_key_ids=["<ssh-key-id>"],
+)
+cluster = client.kubernetes.wait(cluster["id"])
+
+client.kubernetes.list()
+client.kubernetes.get(cluster["id"])
+client.kubernetes.history(cluster["id"])
+client.kubernetes.delete(cluster["id"], confirm_name="shop")
+
+# Node pools (labels, taints, per-pool SSH keys)
+client.kubernetes.add_node_pool(
+    cluster["id"], "workers", "k8s-node-2c4g", 3,
+    labels={"role": "worker"},
+    taints=[{"key": "dedicated", "value": "gpu", "effect": "NoSchedule"}],
+    ssh_key_ids=["<ssh-key-id>"],
+)
+client.kubernetes.scale_node_pool(cluster["id"], "workers", 5)
+client.kubernetes.delete_node_pool(cluster["id"], "workers")
+
+# Access — the kubeconfig is a secret; restrict the API to your CIDRs
+client.kubernetes.kubeconfig(cluster["id"])  # YAML text
+client.kubernetes.set_api_access(cluster["id"], ["203.0.113.7/32"])
+
+# Public IPs and reverse DNS (allocate/release return the updated cluster)
+cluster = client.kubernetes.allocate_ip(cluster["id"])
+address = cluster["public_ips"][-1]["address"]
+client.kubernetes.set_ptr(cluster["id"], address, "shop.example.com")
+client.kubernetes.release_ip(cluster["id"], address)
+
+# Backups
+client.kubernetes.backup_policy(cluster["id"])
+client.kubernetes.set_backup_policy(cluster["id"], schedule_cron="0 3 * * *", retention_days=14)
+client.kubernetes.backups(cluster["id"])
+client.kubernetes.backup_now(cluster["id"])
+client.kubernetes.restore(cluster["id"], "<backup-id>")
+
+# Upgrades — no backup is taken automatically, create one first
+client.kubernetes.available_upgrades(cluster["id"])
+client.kubernetes.upgrade(cluster["id"], "1.34")
+```
+
 ## Error handling
 
 ```python
@@ -109,6 +171,10 @@ Automatic retries on 429, 502, 503, 504 with exponential backoff. Respects `Retr
 - Python 3.10+
 - httpx
 
+## Changelog
+
+See [CHANGELOG.md](https://github.com/wayscloudas/wayscloud-python-sdk/blob/main/CHANGELOG.md).
+
 ## License
 
 MIT — see [LICENSE](LICENSE).

wayscloud-0.4.0/README.md

@@ -0,0 +1,157 @@
+# WAYSCloud Python SDK
+
+Official Python SDK for the [WAYSCloud](https://wayscloud.services) API.
+
+## Installation
+
+```bash
+pip install wayscloud
+```
+
+## Authentication
+
+```python
+from wayscloud import WaysCloudClient
+
+# Personal Access Token
+client = WaysCloudClient(token="wayscloud_pat_...")
+
+# API key
+client = WaysCloudClient(api_key="wayscloud_api_...")
+
+# Environment variables (WAYSCLOUD_TOKEN or WAYSCLOUD_API_KEY)
+client = WaysCloudClient()
+```
+
+Priority: explicit arguments > environment variables.
+
+## Usage
+
+```python
+# VPS
+for vm in client.vps.list():
+    print(vm["hostname"], vm["status"])
+
+# DNS
+client.dns.create_record(
+    "example.com",
+    record_type="A",
+    name="www",
+    value="192.0.2.1",
+)
+
+# Database
+db = client.database.create(name="prod", db_type="postgresql")
+
+# Apps
+app = client.apps.create(name="my-app", region="eu")
+
+# Storage
+client.storage.create_bucket("my-bucket")
+
+# SMS
+client.sms.send(to="+4712345678", message="Hello from WAYSCloud")
+```
+
+## Kubernetes
+
+`client.kubernetes` manages Managed Kubernetes clusters (PAT scopes
+`kubernetes:read` / `kubernetes:write`). Create and delete are asynchronous:
+the API answers `202` with status `provisioning` / `deleting`, and `wait()`
+blocks until the cluster is `running`, `error`, or gone.
+
+```python
+# Catalogue
+client.kubernetes.plans(region="no", kind="node")
+client.kubernetes.regions()
+client.kubernetes.versions()
+client.kubernetes.estimate(
+    plan_code="k8s-cluster-dev",
+    node_pools=[{"name": "default", "plan_code": "k8s-node-2c4g", "count": 2}],
+)
+
+# Clusters
+cluster = client.kubernetes.create(
+    "shop",
+    node_pools=[{"name": "default", "plan_code": "k8s-node-2c4g", "count": 2}],
+    ssh_key_ids=["<ssh-key-id>"],
+)
+cluster = client.kubernetes.wait(cluster["id"])
+
+client.kubernetes.list()
+client.kubernetes.get(cluster["id"])
+client.kubernetes.history(cluster["id"])
+client.kubernetes.delete(cluster["id"], confirm_name="shop")
+
+# Node pools (labels, taints, per-pool SSH keys)
+client.kubernetes.add_node_pool(
+    cluster["id"], "workers", "k8s-node-2c4g", 3,
+    labels={"role": "worker"},
+    taints=[{"key": "dedicated", "value": "gpu", "effect": "NoSchedule"}],
+    ssh_key_ids=["<ssh-key-id>"],
+)
+client.kubernetes.scale_node_pool(cluster["id"], "workers", 5)
+client.kubernetes.delete_node_pool(cluster["id"], "workers")
+
+# Access — the kubeconfig is a secret; restrict the API to your CIDRs
+client.kubernetes.kubeconfig(cluster["id"])  # YAML text
+client.kubernetes.set_api_access(cluster["id"], ["203.0.113.7/32"])
+
+# Public IPs and reverse DNS (allocate/release return the updated cluster)
+cluster = client.kubernetes.allocate_ip(cluster["id"])
+address = cluster["public_ips"][-1]["address"]
+client.kubernetes.set_ptr(cluster["id"], address, "shop.example.com")
+client.kubernetes.release_ip(cluster["id"], address)
+
+# Backups
+client.kubernetes.backup_policy(cluster["id"])
+client.kubernetes.set_backup_policy(cluster["id"], schedule_cron="0 3 * * *", retention_days=14)
+client.kubernetes.backups(cluster["id"])
+client.kubernetes.backup_now(cluster["id"])
+client.kubernetes.restore(cluster["id"], "<backup-id>")
+
+# Upgrades — no backup is taken automatically, create one first
+client.kubernetes.available_upgrades(cluster["id"])
+client.kubernetes.upgrade(cluster["id"], "1.34")
+```
+
+## Error handling
+
+```python
+from wayscloud import NotFoundError, AuthenticationError
+
+try:
+    client.vps.get("id")
+except NotFoundError:
+    print("Not found")
+except AuthenticationError:
+    print("Invalid credentials")
+```
+
+All exceptions inherit from `WaysCloudError`.
+
+## Configuration
+
+| Parameter | Environment variable | Default |
+|-----------|---------------------|---------|
+| `token` | `WAYSCLOUD_TOKEN` | — |
+| `api_key` | `WAYSCLOUD_API_KEY` | — |
+| `base_url` | `WAYSCLOUD_API_URL` | `https://api.wayscloud.services` |
+| `timeout` | — | `30.0` |
+
+## Retries
+
+Automatic retries on 429, 502, 503, 504 with exponential backoff. Respects `Retry-After` headers.
+
+## Requirements
+
+- Python 3.10+
+- httpx
+
+## Changelog
+
+See [CHANGELOG.md](https://github.com/wayscloudas/wayscloud-python-sdk/blob/main/CHANGELOG.md).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

{wayscloud-0.2.3 → wayscloud-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "wayscloud"
-version = "0.2.3"
+version = "0.4.0"
 description = "Official Python SDK for the WAYSCloud API"
 readme = "README.md"
 license = {text = "MIT"}

{wayscloud-0.2.3 → wayscloud-0.4.0}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = wayscloud
-version = 0.2.3
+version = 0.4.0
 description = Official Python SDK for the WAYSCloud API
 long_description = file: README.md
 long_description_content_type = text/markdown

wayscloud-0.4.0/tests/test_kubernetes_service.py

@@ -0,0 +1,117 @@
+"""KubernetesService request shapes against a fake client (no HTTP)."""
+import importlib.util
+import os
+import sys
+import types
+import unittest
+
+HERE = os.path.dirname(__file__)
+SDK = os.path.join(HERE, "..")
+
+try:
+    # Normal case (repo root on sys.path or package installed): use the real
+    # package so later test modules can still import `wayscloud`.
+    from wayscloud.exceptions import NotFoundError
+    from wayscloud.services.kubernetes import KubernetesService
+except ImportError:
+    # Standalone fallback: load the service module without importing the
+    # package __init__ (which needs httpx).
+    pkg = types.ModuleType("wayscloud"); pkg.__path__ = [os.path.join(SDK, "wayscloud")]
+    sys.modules.setdefault("wayscloud", pkg)
+    exc_mod = types.ModuleType("wayscloud.exceptions")
+
+
+    class WaysCloudError(Exception):
+        pass
+
+
+    class NotFoundError(WaysCloudError):
+        pass
+
+
+    exc_mod.WaysCloudError, exc_mod.NotFoundError = WaysCloudError, NotFoundError
+    sys.modules["wayscloud.exceptions"] = exc_mod
+    spec = importlib.util.spec_from_file_location("wayscloud.services.kubernetes", os.path.join(SDK, "wayscloud", "services", "kubernetes.py"))
+    mod = importlib.util.module_from_spec(spec); sys.modules[spec.name] = mod; spec.loader.exec_module(mod)
+    KubernetesService = mod.KubernetesService
+
+
+class FakeClient:
+    def __init__(self, responses=None):
+        self.calls, self.responses = [], list(responses or [])
+
+    def _rec(self, method, path, **kw):
+        self.calls.append((method, path, kw))
+        return self.responses.pop(0) if self.responses else {}
+
+    def get(self, path, params=None, raw=False):
+        return self._rec("GET", path, params=params, raw=raw)
+
+    def post(self, path, json=None):
+        return self._rec("POST", path, json=json)
+
+    def put(self, path, json=None):
+        return self._rec("PUT", path, json=json)
+
+    def delete(self, path, json=None):
+        return self._rec("DELETE", path, json=json)
+
+
+class ServiceTests(unittest.TestCase):
+    def test_create_payload(self):
+        c = FakeClient([{"id": "c1", "status": "provisioning"}])
+        out = KubernetesService(c).create("shop", [{"name": "default", "plan_code": "k8s-node-2c4g", "count": 2}], api_ip_filter=["1.2.3.0/24"])
+        self.assertEqual(out["id"], "c1")
+        m, p, kw = c.calls[0]
+        self.assertEqual((m, p), ("POST", "/v1/kubernetes/clusters"))
+        self.assertEqual(kw["json"]["node_pools"][0]["count"], 2)
+        self.assertEqual(kw["json"]["plan_code"], "k8s-cluster-dev")
+        self.assertEqual(kw["json"]["ssh_key_ids"], [])
+
+    def test_add_node_pool_sends_labels_taints_and_ssh_keys(self):
+        c = FakeClient([{"id": "c1"}])
+        KubernetesService(c).add_node_pool(
+            "c1", "workers", "k8s-node-2c4g", 2,
+            labels={"role": "worker"},
+            taints=[{"key": "dedicated", "value": "gpu", "effect": "NoSchedule"}],
+            ssh_key_ids=["11111111-1111-1111-1111-111111111111"])
+        m, p, kw = c.calls[0]
+        self.assertEqual((m, p), ("POST", "/v1/kubernetes/clusters/c1/node-pools"))
+        self.assertEqual(kw["json"]["labels"], {"role": "worker"})
+        self.assertEqual(kw["json"]["taints"], [{"key": "dedicated", "value": "gpu", "effect": "NoSchedule"}])
+        self.assertEqual(kw["json"]["ssh_key_ids"], ["11111111-1111-1111-1111-111111111111"])
+        self.assertEqual(kw["json"]["count"], 2)
+
+    def test_add_node_pool_defaults_are_empty(self):
+        c = FakeClient([{"id": "c1"}])
+        KubernetesService(c).add_node_pool("c1", "workers", "k8s-node-2c4g", 1)
+        self.assertEqual(c.calls[0][2]["json"], {"name": "workers", "plan_code": "k8s-node-2c4g", "count": 1,
+                                                 "labels": {}, "taints": [], "ssh_key_ids": []})
+
+    def test_delete_sends_confirmation_body(self):
+        c = FakeClient([{"status": "deleting"}])
+        KubernetesService(c).delete("c1", "shop")
+        self.assertEqual(c.calls[0], ("DELETE", "/v1/kubernetes/clusters/c1", {"json": {"confirm_name": "shop"}}))
+
+    def test_kubeconfig_is_raw_text(self):
+        c = FakeClient(["apiVersion: v1"])
+        self.assertEqual(KubernetesService(c).kubeconfig("c1"), "apiVersion: v1")
+        self.assertTrue(c.calls[0][2]["raw"])
+
+    def test_list_unwraps_envelope(self):
+        c = FakeClient([{"clusters": [{"id": "a"}], "total": 1}])
+        self.assertEqual(KubernetesService(c).list(), [{"id": "a"}])
+
+    def test_wait_returns_on_running_and_on_404(self):
+        c = FakeClient([{"status": "provisioning"}, {"status": "running", "id": "c1"}])
+        svc = KubernetesService(c)
+        self.assertEqual(svc.wait("c1", timeout=5, interval=0)["status"], "running")
+
+        class Gone(FakeClient):
+            def get(self, *a, **k):
+                raise NotFoundError("404")
+        self.assertEqual(KubernetesService(Gone()).wait("c1", timeout=5, interval=0)["status"], "deleted")
+
+
+if __name__ == "__main__":
+    unittest.main()

{wayscloud-0.2.3 → wayscloud-0.4.0}/tests/test_smoke.py

@@ -1,5 +1,6 @@
 """SDK smoke tests — verify public API surface, auth, lifecycle, and error handling."""
 
+import json
 import os
 
 import httpx
@@ -115,29 +116,31 @@ def test_all_services_instantiate():
 
 @respx.mock
 def test_get_returns_json():
-    respx.get("https://api.wayscloud.services/api/v1/dashboard/vps").mock(
-        return_value=httpx.Response(200, json={"instances": []})
+    respx.get("https://api.wayscloud.services/v1/vps/").mock(
+        return_value=httpx.Response(200, json={"total": 1, "vps_instances": [{"id": "vps-1", "hostname": "web01"}]})
     )
     with WaysCloudClient(token="t") as c:
         result = c.vps.list()
-    assert result == []
+    assert result == [{"id": "vps-1", "hostname": "web01"}]
 
 
 @respx.mock
 def test_post_sends_json_body():
-    route = respx.post("https://api.wayscloud.services/api/v1/dashboard/dns/zones").mock(
-        return_value=httpx.Response(201, json={"id": "z1", "name": "example.com"})
+    route = respx.post("https://api.wayscloud.services/v1/dns/zones").mock(
+        return_value=httpx.Response(201, json={"zone_id": "z1", "zone_name": "example.com"})
     )
     with WaysCloudClient(token="t") as c:
         result = c.dns.create_zone("example.com")
-    assert result["name"] == "example.com"
-    assert route.calls[0].request.headers["content-type"] == "application/json"
+    assert result["zone_name"] == "example.com"
+    request = route.calls[0].request
+    assert request.headers["content-type"] == "application/json"
+    assert json.loads(request.content) == {"zone_name": "example.com", "zone_type": "master"}
 
 
 @respx.mock
 def test_get_does_not_send_content_type():
-    route = respx.get("https://api.wayscloud.services/api/v1/dashboard/vps").mock(
-        return_value=httpx.Response(200, json={"instances": []})
+    route = respx.get("https://api.wayscloud.services/v1/vps/").mock(
+        return_value=httpx.Response(200, json={"total": 0, "vps_instances": []})
     )
     with WaysCloudClient(token="t") as c:
         c.vps.list()
@@ -146,7 +149,7 @@ def test_get_does_not_send_content_type():
 
 @respx.mock
 def test_204_returns_ok():
-    respx.delete("https://api.wayscloud.services/api/v1/dashboard/vps/abc").mock(
+    respx.delete("https://api.wayscloud.services/v1/vps/abc").mock(
         return_value=httpx.Response(204)
     )
     with WaysCloudClient(token="t") as c:
@@ -158,7 +161,7 @@ def test_204_returns_ok():
 
 @respx.mock
 def test_401_raises_authentication_error():
-    respx.get("https://api.wayscloud.services/api/v1/dashboard/vps").mock(
+    respx.get("https://api.wayscloud.services/v1/vps/").mock(
         return_value=httpx.Response(401, json={"detail": "Invalid token"})
     )
     with WaysCloudClient(token="t") as c:
@@ -169,7 +172,7 @@ def test_401_raises_authentication_error():
 
 @respx.mock
 def test_404_raises_not_found():
-    respx.get("https://api.wayscloud.services/api/v1/dashboard/vps/bad").mock(
+    respx.get("https://api.wayscloud.services/v1/vps/bad").mock(
         return_value=httpx.Response(404, json={"detail": "Not found"})
     )
     with WaysCloudClient(token="t") as c:
@@ -179,7 +182,7 @@ def test_404_raises_not_found():
 
 @respx.mock
 def test_422_raises_validation_error():
-    respx.post("https://api.wayscloud.services/api/v1/dashboard/dns/zones").mock(
+    respx.post("https://api.wayscloud.services/v1/dns/zones").mock(
         return_value=httpx.Response(422, json={"detail": "Invalid zone name"})
     )
     with WaysCloudClient(token="t") as c:
@@ -189,7 +192,7 @@ def test_422_raises_validation_error():
 
 @respx.mock
 def test_500_raises_server_error():
-    respx.get("https://api.wayscloud.services/api/v1/dashboard/vps").mock(
+    respx.get("https://api.wayscloud.services/v1/vps/").mock(
         return_value=httpx.Response(500, json={"detail": "Internal error"})
     )
     with WaysCloudClient(token="t") as c:
@@ -201,16 +204,16 @@ def test_500_raises_server_error():
 
 @respx.mock
 def test_retries_on_429_then_succeeds():
-    route = respx.get("https://api.wayscloud.services/api/v1/dashboard/vps").mock(
+    route = respx.get("https://api.wayscloud.services/v1/vps/").mock(
         side_effect=[
             httpx.Response(429),
-            httpx.Response(200, json={"instances": [{"hostname": "ok"}]}),
+            httpx.Response(200, json={"total": 1, "vps_instances": [{"hostname": "ok"}]}),
         ]
     )
     with WaysCloudClient(token="t") as c:
         c.BACKOFF_FACTOR = 0.01  # Speed up test
         result = c.vps.list()
-    assert len(result) == 1
+    assert result == [{"hostname": "ok"}]
     assert route.call_count == 2
 
 

wayscloud-0.4.0/wayscloud/_version.py

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

{wayscloud-0.2.3 → wayscloud-0.4.0}/wayscloud/client.py

@@ -86,10 +86,12 @@ class WaysCloudClient:
         self._storage: Optional[Any] = None
         self._database: Optional[Any] = None
         self._redis: Optional[Any] = None
+        self._kubernetes: Optional[Any] = None
         self._apps: Optional[Any] = None
         self._iot: Optional[Any] = None
         self._sms: Optional[Any] = None
         self._account: Optional[Any] = None
+        self._impact: Optional[Any] = None
 
     # ── Lifecycle ─────────────────────────────────────────────────
 
@@ -111,9 +113,13 @@ class WaysCloudClient:
         path: str,
         json: Any = None,
         params: Optional[dict] = None,
+        raw: bool = False,
     ) -> Any:
         """Execute HTTP request with retry and error mapping.
 
+        ``raw=True`` returns the response body as text (e.g. a kubeconfig YAML)
+        instead of decoding JSON.
+
         Retries up to MAX_RETRIES times on 429/502/503/504 with exponential
         backoff. Maps HTTP error codes to typed exceptions.
         """
@@ -134,8 +140,10 @@ class WaysCloudClient:
                     params=params,
                 )
 
-                # Success
-                if response.status_code in (200, 201):
+                # Success (202 = accepted, asynchronous operations such as cluster create/delete)
+                if response.status_code in (200, 201, 202):
+                    if raw:
+                        return response.text
                     try:
                         return response.json()
                     except Exception:
@@ -217,9 +225,9 @@ class WaysCloudClient:
         else:
             raise WaysCloudError(message=message, status_code=status, detail=detail)
 
-    def get(self, path: str, params: Optional[dict] = None) -> Any:
-        """Execute GET request."""
-        return self._request("GET", path, params=params)
+    def get(self, path: str, params: Optional[dict] = None, raw: bool = False) -> Any:
+        """Execute GET request. ``raw=True`` returns text instead of JSON."""
+        return self._request("GET", path, params=params, raw=raw)
 
     def post(self, path: str, json: Any = None) -> Any:
         """Execute POST request."""
@@ -233,9 +241,9 @@ class WaysCloudClient:
         """Execute PATCH request."""
         return self._request("PATCH", path, json=json)
 
-    def delete(self, path: str) -> Any:
-        """Execute DELETE request."""
-        return self._request("DELETE", path)
+    def delete(self, path: str, json: Any = None) -> Any:
+        """Execute DELETE request (optionally with a JSON body, e.g. a confirmation)."""
+        return self._request("DELETE", path, json=json)
 
     # ── Lazy service properties ───────────────────────────────────
 
@@ -279,6 +287,14 @@ class WaysCloudClient:
             self._redis = RedisService(self)
         return self._redis
 
+    @property
+    def kubernetes(self):
+        """Managed Kubernetes clusters (/v1/kubernetes)."""
+        if self._kubernetes is None:
+            from .services.kubernetes import KubernetesService
+            self._kubernetes = KubernetesService(self)
+        return self._kubernetes
+
     @property
     def apps(self):
         """App Platform service."""
@@ -310,3 +326,11 @@ class WaysCloudClient:
             from .services.account import AccountService
             self._account = AccountService(self)
         return self._account
+
+    @property
+    def impact(self):
+        """Impact Trees service — customer-funded reforestation contributions."""
+        if self._impact is None:
+            from .services.impact import ImpactService
+            self._impact = ImpactService(self)
+        return self._impact

{wayscloud-0.2.3 → wayscloud-0.4.0}/wayscloud/services/apps.py

@@ -102,3 +102,42 @@ class AppService:
     # domains(), add_domain(), remove_domain() removed.
     # No public /v1/apps/{id}/domains endpoint exists (404 verified).
     # Domain management is dashboard-only.
+
+    # ── GitHub auto-deploy ────────────────────────────────────────
+    # Dashboard-only endpoints. PAT auth is accepted by the
+    # get_authenticated_customer_or_internal dependency, so SDK/CLI
+    # callers can reach /v1/dashboard/apps/.../auto-deploy/github
+    # with the same PAT they already use for /v1/apps.
+
+    def auto_deploy_get(self, app_id: str) -> dict:
+        """Return GitHub auto-deploy config for the app (no secret)."""
+        return self._client.get(
+            f"/v1/dashboard/apps/{app_id}/auto-deploy/github"
+        )
+
+    def auto_deploy_configure(
+        self,
+        app_id: str,
+        repo_url: str,
+        branch: str = "main",
+        auto_deploy_enabled: bool = True,
+    ) -> dict:
+        """Configure/update GitHub auto-deploy.
+
+        The first call for an app returns the generated webhook_secret
+        in the response — surface it to the user exactly once.
+        """
+        return self._client.put(
+            f"/v1/dashboard/apps/{app_id}/auto-deploy/github",
+            json={
+                "repo_url": repo_url,
+                "branch": branch,
+                "auto_deploy_enabled": auto_deploy_enabled,
+            },
+        )
+
+    def auto_deploy_rotate_secret(self, app_id: str) -> dict:
+        """Rotate the per-app webhook secret. Returns the new one once."""
+        return self._client.post(
+            f"/v1/dashboard/apps/{app_id}/auto-deploy/github/rotate-secret"
+        )

{wayscloud-0.2.3 → wayscloud-0.4.0}/wayscloud/services/database.py

@@ -59,17 +59,30 @@ class DatabaseService:
         data = self._client.get(f"/v1/databases/{db_type}/{name}/firewall")
         return data if isinstance(data, list) else data.get("rules", [])
 
-    def add_firewall_rule(self, db_type: str, name: str, source: str) -> dict:
-        """Add a firewall rule to allow access from a CIDR."""
+    def add_firewall_rule(self, db_type: str, name: str, ip_address: str, description: str = "") -> dict:
+        """Add a firewall rule to whitelist an IP address.
+
+        Args:
+            db_type: Database type (postgresql or mariadb).
+            name: Database name.
+            ip_address: IPv4 address to whitelist (e.g., '203.0.113.50').
+            description: Optional description.
+        """
+        body: dict = {"ip_address": ip_address}
+        if description:
+            body["description"] = description
         return self._client.post(
             f"/v1/databases/{db_type}/{name}/firewall",
-            json={"source": source},
+            json=body,
         )
 
     def remove_firewall_rule(self, db_type: str, name: str, rule_id: str) -> dict:
         """Remove a firewall rule."""
         return self._client.delete(f"/v1/databases/{db_type}/{name}/firewall/{rule_id}")
 
-    # credentials() removed — no public /v1/databases/.../credentials endpoint.
-    # Connection credentials are returned in create() response.
-    # tiers() removed — no public endpoint. Dashboard-only discovery.
+    # ── Tiers ──────────────────────────────────────────────────────
+
+    def tiers(self) -> list[dict]:
+        """List available database tiers (standard, encrypted)."""
+        data = self._client.get("/v1/databases/tiers")
+        return data if isinstance(data, list) else data.get("tiers", [])