wayscloud 0.3.0__tar.gz → 0.4.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wayscloud
-Version: 0.3.0
+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.3.0 → wayscloud-0.4.0}/pyproject.toml

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

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

@@ -1,6 +1,6 @@
 [metadata]
 name = wayscloud
-version = 0.3.0
+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.3.0 → 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.3.0 → 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.3.0 → 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.4.0/wayscloud/services/impact.py

@@ -0,0 +1,76 @@
+"""Impact service — customer-funded reforestation contributions.
+
+Maps 1:1 to /v1/impact/* endpoints. Mock provider only at MVP — every item
+where `provider == 'mock'` carries `demo_data: True` from the server.
+"""
+
+from __future__ import annotations
+
+import uuid as _uuid
+from typing import Optional
+
+
+class ImpactService:
+    """Forests, tree commitments, items (seeds/sprouts/trees), and feed."""
+
+    def __init__(self, client):
+        self._client = client
+
+    # ── Forests ───────────────────────────────────────────────────
+
+    def create_forest(self, name: str) -> dict:
+        return self._client.post("/v1/impact/forests", json={"name": name})
+
+    def list_forests(self) -> list[dict]:
+        data = self._client.get("/v1/impact/forests")
+        return data.get("forests", data) if isinstance(data, dict) else data
+
+    def forest_status(self, forest: str) -> dict:
+        """Counts by stage + commitment buckets. `forest` may be UUID or name."""
+        return self._client.get(f"/v1/impact/forests/{forest}")
+
+    def forest_feed(self, forest: str, limit: int = 20) -> list[dict]:
+        data = self._client.get(
+            f"/v1/impact/forests/{forest}/feed", params={"limit": limit}
+        )
+        return data.get("feed", data) if isinstance(data, dict) else data
+
+    # ── Tree commitments ──────────────────────────────────────────
+
+    def commit_trees(
+        self,
+        forest: str,
+        quantity: int,
+        idempotency_key: Optional[str] = None,
+    ) -> dict:
+        """Commit N trees to a forest. Server returns the commitment + items.
+
+        Idempotency: same idempotency_key returns the same commitment. If
+        omitted, the SDK generates a UUID4 client-side so retries on transient
+        network failures don't double-charge.
+        """
+        body = {
+            "forest_id": forest,
+            "quantity": quantity,
+            "idempotency_key": idempotency_key or f"sdk_{_uuid.uuid4().hex}",
+        }
+        return self._client.post("/v1/impact/tree-commitments", json=body)
+
+    def list_commitments(self, limit: int = 50) -> list[dict]:
+        data = self._client.get(
+            "/v1/impact/tree-commitments", params={"limit": limit}
+        )
+        return data.get("commitments", data) if isinstance(data, dict) else data
+
+    def get_commitment(self, commitment_id: str) -> dict:
+        return self._client.get(f"/v1/impact/tree-commitments/{commitment_id}")
+
+    # ── Items (seeds / sprouts / trees) ───────────────────────────
+
+    def get_tree(self, item_id: str) -> dict:
+        """`item_id` may be a UUID or an external short id like 'seed_81ab1f2c93'."""
+        return self._client.get(f"/v1/impact/trees/{item_id}")
+
+    def water_tree(self, item_id: str) -> dict:
+        """Cosmetic watering. Rate-limited server-side to once per 24h."""
+        return self._client.post(f"/v1/impact/trees/{item_id}/water", json={})

wayscloud-0.4.0/wayscloud/services/kubernetes.py

@@ -0,0 +1,159 @@
+"""Kubernetes service -- Managed Kubernetes clusters."""
+
+from __future__ import annotations
+
+import time
+from typing import Optional
+
+
+class KubernetesService:
+    """Manage Kubernetes clusters.
+
+    All methods use the public API at /v1/kubernetes (PAT with the
+    ``kubernetes:read`` / ``kubernetes:write`` scopes, or API key auth).
+    Create and delete are asynchronous: the API answers 202 with the cluster
+    in status ``provisioning`` / ``deleting``; use :meth:`wait` to block.
+    """
+
+    TERMINAL = {"running", "error", "deleted"}
+
+    def __init__(self, client):
+        self._client = client
+
+    # -- catalogue -----------------------------------------------------------
+    def plans(self, region: str = "no", kind: Optional[str] = None) -> list[dict]:
+        """List cluster and node plans (``kind``: controlplane, node, ip, lb, storage, backup)."""
+        params = {"region": region}
+        if kind:
+            params["kind"] = kind
+        data = self._client.get("/v1/kubernetes/plans", params=params)
+        return data.get("plans", []) if isinstance(data, dict) else data
+
+    def regions(self) -> list[dict]:
+        data = self._client.get("/v1/kubernetes/regions")
+        return data.get("regions", []) if isinstance(data, dict) else data
+
+    def versions(self) -> dict:
+        return self._client.get("/v1/kubernetes/versions")
+
+    def estimate(self, plan_code: str, node_pools: list[dict], currency: str = "NOK", region: str = "no") -> dict:
+        return self._client.post("/v1/kubernetes/estimate",
+                                 json={"plan_code": plan_code, "node_pools": node_pools, "currency": currency, "region": region})
+
+    # -- clusters ------------------------------------------------------------
+    def list(self) -> list[dict]:
+        data = self._client.get("/v1/kubernetes/clusters")
+        return data.get("clusters", []) if isinstance(data, dict) else data
+
+    def get(self, cluster_id: str) -> dict:
+        return self._client.get(f"/v1/kubernetes/clusters/{cluster_id}")
+
+    def create(
+        self,
+        name: str,
+        node_pools: list[dict],
+        plan_code: str = "k8s-cluster-dev",
+        region: str = "no",
+        version: str = "1.34",
+        api_ip_filter: Optional[list[str]] = None,
+        ssh_key_ids: Optional[list[str]] = None,
+    ) -> dict:
+        """Create a cluster. ``node_pools``: ``[{"name": "default", "plan_code": "k8s-node-2c4g", "count": 2}]``."""
+        return self._client.post("/v1/kubernetes/clusters", json={
+            "name": name, "region": region, "plan_code": plan_code, "version": version,
+            "node_pools": node_pools, "api_ip_filter": api_ip_filter or [], "ssh_key_ids": ssh_key_ids or [],
+        })
+
+    def delete(self, cluster_id: str, confirm_name: str) -> dict:
+        """Delete a cluster. ``confirm_name`` must equal the cluster's name."""
+        return self._client.delete(f"/v1/kubernetes/clusters/{cluster_id}", json={"confirm_name": confirm_name})
+
+    def wait(self, cluster_id: str, timeout: int = 1800, interval: int = 15) -> dict:
+        """Poll until the cluster reaches running/error (or is gone after a delete)."""
+        from ..exceptions import NotFoundError
+
+        deadline = time.time() + timeout
+        while True:
+            try:
+                c = self.get(cluster_id)
+            except NotFoundError:  # gone after a delete: terminal
+                return {"id": cluster_id, "status": "deleted"}
+            if c.get("status") in self.TERMINAL:
+                return c
+            if time.time() > deadline:
+                raise TimeoutError(f"cluster {cluster_id} still {c.get('status')} after {timeout}s")
+            time.sleep(interval)
+
+    def history(self, cluster_id: str) -> list[dict]:
+        data = self._client.get(f"/v1/kubernetes/clusters/{cluster_id}/history")
+        return data.get("events", []) if isinstance(data, dict) else data
+
+    # -- node pools ----------------------------------------------------------
+    def add_node_pool(self, cluster_id: str, name: str, plan_code: str, count: int,
+                      labels: Optional[dict] = None, taints: Optional[list[dict]] = None,
+                      ssh_key_ids: Optional[list[str]] = None) -> dict:
+        """Add a node pool. ``count`` must be 1-16; ``taints`` entries are
+        ``{"key": ..., "value": ..., "effect": ...}``. ``ssh_key_ids`` must be
+        SSH key ids on the account (ownership is validated by the API)."""
+        return self._client.post(f"/v1/kubernetes/clusters/{cluster_id}/node-pools",
+                                 json={"name": name, "plan_code": plan_code, "count": count, "labels": labels or {},
+                                       "taints": taints or [], "ssh_key_ids": ssh_key_ids or []})
+
+    def scale_node_pool(self, cluster_id: str, pool_name: str, count: int) -> dict:
+        """Scale a node pool. ``count`` must be between 1 and 16; scale-to-zero is not supported."""
+        return self._client.post(f"/v1/kubernetes/clusters/{cluster_id}/node-pools/{pool_name}/scale", json={"count": count})
+
+    def delete_node_pool(self, cluster_id: str, pool_name: str) -> dict:
+        return self._client.delete(f"/v1/kubernetes/clusters/{cluster_id}/node-pools/{pool_name}")
+
+    # -- access --------------------------------------------------------------
+    def kubeconfig(self, cluster_id: str) -> str:
+        """Admin kubeconfig as YAML text. Treat as a secret."""
+        return self._client.get(f"/v1/kubernetes/clusters/{cluster_id}/kubeconfig", raw=True)
+
+    def set_api_access(self, cluster_id: str, cidrs: list[str]) -> dict:
+        """Set the CIDRs allowed to reach the Kubernetes API. An empty list means the API is
+        only reachable from WAYSCloud infrastructure; add the client CIDR for external
+        kubectl/API access."""
+        return self._client.put(f"/v1/kubernetes/clusters/{cluster_id}/api-access", json={"cidrs": cidrs})
+
+    # -- public IPs ----------------------------------------------------------
+    def allocate_ip(self, cluster_id: str) -> dict:
+        return self._client.post(f"/v1/kubernetes/clusters/{cluster_id}/ips")
+
+    def release_ip(self, cluster_id: str, address: str) -> dict:
+        return self._client.delete(f"/v1/kubernetes/clusters/{cluster_id}/ips/{address}")
+
+    def set_ptr(self, cluster_id: str, address: str, ptr_record: str) -> dict:
+        """Set reverse DNS. The name must already resolve to the address."""
+        return self._client.put(f"/v1/kubernetes/clusters/{cluster_id}/ips/{address}/ptr", json={"ptr_record": ptr_record})
+
+    # -- backups -------------------------------------------------------------
+    def backup_policy(self, cluster_id: str) -> dict:
+        return self._client.get(f"/v1/kubernetes/clusters/{cluster_id}/backup-policy")
+
+    def set_backup_policy(self, cluster_id: str, *, enabled: bool = True, schedule_cron: str = "0 3 * * *",
+                          retention_days: int = 14, include_volumes: bool = True, namespaces: Optional[list[str]] = None) -> dict:
+        return self._client.put(f"/v1/kubernetes/clusters/{cluster_id}/backup-policy", json={
+            "enabled": enabled, "schedule_cron": schedule_cron, "retention_days": retention_days,
+            "include_volumes": include_volumes, "namespaces": namespaces})
+
+    def backups(self, cluster_id: str) -> list[dict]:
+        data = self._client.get(f"/v1/kubernetes/clusters/{cluster_id}/backups")
+        return data.get("backups", []) if isinstance(data, dict) else data
+
+    def backup_now(self, cluster_id: str, namespaces: Optional[list[str]] = None) -> dict:
+        return self._client.post(f"/v1/kubernetes/clusters/{cluster_id}/backups", json={"namespaces": namespaces})
+
+    def restore(self, cluster_id: str, backup_id: str, namespaces: Optional[list[str]] = None) -> dict:
+        return self._client.post(f"/v1/kubernetes/clusters/{cluster_id}/backups/{backup_id}/restore", json={"namespaces": namespaces})
+
+    # -- upgrades ------------------------------------------------------------
+    def available_upgrades(self, cluster_id: str) -> list[str]:
+        data = self._client.get(f"/v1/kubernetes/clusters/{cluster_id}/upgrade")
+        return data.get("versions", []) if isinstance(data, dict) else data
+
+    def upgrade(self, cluster_id: str, version: str) -> dict:
+        """Upgrade the control plane to `version`. No backup is taken automatically; create
+        one first if the workload needs a restore point (the portal shows the same warning)."""
+        return self._client.post(f"/v1/kubernetes/clusters/{cluster_id}/upgrade", json={"version": version})

{wayscloud-0.3.0 → wayscloud-0.4.0}/wayscloud.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wayscloud
-Version: 0.3.0
+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.3.0 → wayscloud-0.4.0}/wayscloud.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 README.md
 pyproject.toml
 setup.cfg
+tests/test_kubernetes_service.py
 tests/test_smoke.py
 wayscloud/__init__.py
 wayscloud/_version.py
@@ -18,7 +19,9 @@ wayscloud/services/account.py
 wayscloud/services/apps.py
 wayscloud/services/database.py
 wayscloud/services/dns.py
+wayscloud/services/impact.py
 wayscloud/services/iot.py
+wayscloud/services/kubernetes.py
 wayscloud/services/redis.py
 wayscloud/services/sms.py
 wayscloud/services/storage.py

wayscloud-0.3.0/README.md

@@ -1,91 +0,0 @@
-# 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")
-```
-
-## 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
-
-## License
-
-MIT — see [LICENSE](LICENSE).

wayscloud-0.3.0/wayscloud/_version.py

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