wayscloud 0.1.0__tar.gz → 0.2.3__tar.gz

{wayscloud-0.1.0/wayscloud.egg-info → wayscloud-0.2.3}/PKG-INFO

@@ -1,11 +1,13 @@
 Metadata-Version: 2.4
 Name: wayscloud
-Version: 0.1.0
+Version: 0.2.3
 Summary: Official Python SDK for the WAYSCloud API
 Home-page: https://wayscloud.services
 License: MIT
 Project-URL: Homepage, https://wayscloud.services
-Project-URL: Documentation, https://docs.wayscloud.services
+Project-URL: Documentation, https://docs.wayscloud.services/integrations/sdk
+Project-URL: Repository, https://github.com/wayscloudas/wayscloud-provision-api
+Project-URL: Issues, https://github.com/wayscloudas/wayscloud-provision-api/issues
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

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

@@ -1,6 +1,6 @@
 [project]
 name = "wayscloud"
-version = "0.1.0"
+version = "0.2.3"
 description = "Official Python SDK for the WAYSCloud API"
 readme = "README.md"
 license = {text = "MIT"}
@@ -18,7 +18,9 @@ classifiers = [
 
 [project.urls]
 Homepage = "https://wayscloud.services"
-Documentation = "https://docs.wayscloud.services"
+Documentation = "https://docs.wayscloud.services/integrations/sdk"
+Repository = "https://github.com/wayscloudas/wayscloud-provision-api"
+Issues = "https://github.com/wayscloudas/wayscloud-provision-api/issues"
 
 [tool.setuptools.packages.find]
 include = ["wayscloud*"]

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

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

wayscloud-0.2.3/wayscloud/__init__.py

@@ -0,0 +1,25 @@
+from .client import WaysCloudClient
+from .exceptions import (
+    WaysCloudError,
+    AuthenticationError,
+    ConflictError,
+    NotFoundError,
+    NotImplementedError_,
+    RateLimitError,
+    ServerError,
+    ValidationError,
+)
+from ._version import __version__
+
+__all__ = [
+    "WaysCloudClient",
+    "WaysCloudError",
+    "AuthenticationError",
+    "ConflictError",
+    "NotFoundError",
+    "NotImplementedError_",
+    "RateLimitError",
+    "ServerError",
+    "ValidationError",
+    "__version__",
+]

wayscloud-0.2.3/wayscloud/_version.py

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

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

@@ -15,7 +15,10 @@ import httpx
 from ._version import __version__
 from .exceptions import (
     AuthenticationError,
+    ConflictError,
     NotFoundError,
+    NotImplementedError_,
+    RateLimitError,
     ServerError,
     ValidationError,
     WaysCloudError,
@@ -75,7 +78,7 @@ class WaysCloudClient:
             self._headers["X-API-Key"] = api_key
 
         # Persistent HTTP client for connection pooling
-        self._http = httpx.Client(timeout=self.timeout)
+        self._http = httpx.Client(timeout=self.timeout, follow_redirects=True)
 
         # Lazy service instances
         self._vps: Optional[Any] = None
@@ -201,8 +204,14 @@ class WaysCloudClient:
             raise AuthenticationError(message=message, status_code=status, detail=detail)
         elif status == 404:
             raise NotFoundError(message=message, status_code=status, detail=detail)
-        elif status == 422:
+        elif status in (400, 422):
             raise ValidationError(message=message, status_code=status, detail=detail)
+        elif status == 409:
+            raise ConflictError(message=message, status_code=status, detail=detail)
+        elif status == 429:
+            raise RateLimitError(message=message, status_code=status, detail=detail)
+        elif status == 501:
+            raise NotImplementedError_(message=message, status_code=status, detail=detail)
         elif status >= 500:
             raise ServerError(message=message, status_code=status, detail=detail)
         else:

{wayscloud-0.1.0 → wayscloud-0.2.3}/wayscloud/exceptions.py

@@ -19,7 +19,22 @@ class NotFoundError(WaysCloudError):
 
 
 class ValidationError(WaysCloudError):
-    """422 -- request validation failed."""
+    """400/422 -- request validation or input error."""
+    pass
+
+
+class ConflictError(WaysCloudError):
+    """409 -- state conflict (resource busy, duplicate, wrong state)."""
+    pass
+
+
+class RateLimitError(WaysCloudError):
+    """429 -- too many requests or resource limit reached."""
+    pass
+
+
+class NotImplementedError_(WaysCloudError):
+    """501 -- feature not yet available."""
     pass
 
 

wayscloud-0.2.3/wayscloud/services/apps.py

@@ -0,0 +1,104 @@
+"""App Platform service -- container app management."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+
+class AppService:
+    """Manage container apps on the WAYSCloud App Platform.
+
+    All methods use the public API at /v1/apps (API key auth).
+    """
+
+    def __init__(self, client):
+        self._client = client
+
+    def list(self) -> list[dict]:
+        """List all apps."""
+        data = self._client.get("/v1/apps")
+        return data.get("apps", data) if isinstance(data, dict) else data
+
+    def get(self, app_id: str) -> dict:
+        """Get details of a specific app."""
+        return self._client.get(f"/v1/apps/{app_id}")
+
+    def create(
+        self,
+        name: str,
+        plan: str = "app-basic",
+        region: str = "no",
+        port: int = 8080,
+    ) -> dict:
+        """Create a new app."""
+        return self._client.post(
+            "/v1/apps",
+            json={"name": name, "plan": plan, "region": region, "port": port},
+        )
+
+    def update(self, app_id: str, **kwargs) -> dict:
+        """Update an app. Pass any updatable fields as kwargs."""
+        return self._client.patch(f"/v1/apps/{app_id}", json=kwargs)
+
+    def delete(self, app_id: str) -> dict:
+        """Delete an app (permanent)."""
+        return self._client.delete(f"/v1/apps/{app_id}")
+
+    def deploy(self, app_id: str, image: str) -> dict:
+        """Deploy an app from a container image URI."""
+        return self._client.post(
+            f"/v1/apps/{app_id}/deploy/image",
+            json={"image_uri": image},
+        )
+
+    def start(self, app_id: str) -> dict:
+        """Start an app."""
+        return self._client.post(f"/v1/apps/{app_id}/start")
+
+    def stop(self, app_id: str) -> dict:
+        """Stop an app."""
+        return self._client.post(f"/v1/apps/{app_id}/stop")
+
+    def restart(self, app_id: str) -> dict:
+        """Restart an app."""
+        return self._client.post(f"/v1/apps/{app_id}/restart")
+
+    def logs(self, app_id: str, lines: int = 100) -> list:
+        """Get app logs."""
+        data = self._client.get(
+            f"/v1/apps/{app_id}/logs",
+            params={"lines": lines},
+        )
+        if isinstance(data, dict):
+            return data.get("logs", data.get("lines", []))
+        return data
+
+    def plans(self) -> list[dict]:
+        """List available app plans."""
+        data = self._client.get("/v1/apps/plans")
+        return data if isinstance(data, list) else data.get("plans", [])
+
+    def regions(self) -> list[dict]:
+        """List available app regions."""
+        data = self._client.get("/v1/apps/regions")
+        return data if isinstance(data, list) else data.get("regions", [])
+
+    # ── Environment variables ─────────────────────────────────────
+    # env_vars are part of the app detail and updated via PATCH
+
+    def env_vars(self, app_id: str) -> dict:
+        """Get environment variables for an app (from app detail)."""
+        data = self.get(app_id)
+        return data.get("env_vars", {}) if isinstance(data, dict) else {}
+
+    def set_env(self, app_id: str, key: str, value: str) -> dict:
+        """Set an environment variable on an app."""
+        return self.update(app_id, env_vars={key: value})
+
+    def unset_env(self, app_id: str, key: str) -> dict:
+        """Remove an environment variable from an app."""
+        return self.update(app_id, env_vars={key: None})
+
+    # domains(), add_domain(), remove_domain() removed.
+    # No public /v1/apps/{id}/domains endpoint exists (404 verified).
+    # Domain management is dashboard-only.

wayscloud-0.2.3/wayscloud/services/database.py

@@ -0,0 +1,75 @@
+"""Database service -- Database-as-a-Service management."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+
+class DatabaseService:
+    """Manage PostgreSQL and MariaDB databases.
+
+    All methods use the public API at /v1/databases (PAT auth).
+    """
+
+    def __init__(self, client):
+        self._client = client
+
+    def list(self) -> list[dict]:
+        """List all databases."""
+        data = self._client.get("/v1/databases")
+        return data if isinstance(data, list) else data.get("databases", [])
+
+    def get(self, db_type: str, name: str) -> dict:
+        """Get details of a specific database.
+
+        Args:
+            db_type: Database type (postgresql or mariadb).
+            name: Database name.
+        """
+        return self._client.get(f"/v1/databases/{db_type}/{name}")
+
+    def create(
+        self,
+        name: str,
+        db_type: str = "postgresql",
+        tier: str = "standard",
+        description: Optional[str] = None,
+    ) -> dict:
+        """Create a new database. Returns credentials on success.
+
+        Args:
+            name: Database name.
+            db_type: Database type (postgresql or mariadb).
+            tier: Database tier (standard or encrypted).
+            description: Optional description.
+        """
+        body: dict = {"name": name, "type": db_type, "tier": tier}
+        if description is not None:
+            body["description"] = description
+        return self._client.post("/v1/databases", json=body)
+
+    def delete(self, db_type: str, name: str) -> dict:
+        """Delete a database (permanent)."""
+        return self._client.delete(f"/v1/databases/{db_type}/{name}")
+
+    # ── Firewall ─────────────────────────────────────────────────
+
+    def firewall_rules(self, db_type: str, name: str) -> list[dict]:
+        """List firewall rules for a database."""
+        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."""
+        return self._client.post(
+            f"/v1/databases/{db_type}/{name}/firewall",
+            json={"source": source},
+        )
+
+    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.

{wayscloud-0.1.0 → wayscloud-0.2.3}/wayscloud/services/dns.py

@@ -6,38 +6,47 @@ from typing import Optional
 
 
 class DNSService:
-    """Manage DNS zones, records, and DNSSEC."""
+    """Manage DNS zones, records, and DNSSEC.
+
+    All methods use the public API at /v1/dns (API key auth).
+    """
 
     def __init__(self, client):
         self._client = client
 
     # ── Zones ─────────────────────────────────────────────────────
 
-    def zones(self) -> list[dict]:
+    def list(self) -> list[dict]:
         """List all DNS zones."""
-        data = self._client.get("/api/v1/dashboard/dns/zones")
+        data = self._client.get("/v1/dns/zones")
         return data.get("zones", data) if isinstance(data, dict) else data
 
-    def get_zone(self, zone_name: str) -> dict:
+    # Alias for backward compatibility
+    zones = list
+
+    def get(self, zone_name: str) -> dict:
         """Get details of a specific DNS zone."""
-        return self._client.get(f"/api/v1/dashboard/dns/zones/{zone_name}")
+        return self._client.get(f"/v1/dns/zones/{zone_name}")
+
+    # Alias
+    get_zone = get
 
     def create_zone(self, name: str, zone_type: str = "master") -> dict:
         """Create a new DNS zone."""
         return self._client.post(
-            "/api/v1/dashboard/dns/zones",
+            "/v1/dns/zones",
             json={"zone_name": name, "zone_type": zone_type},
         )
 
     def delete_zone(self, zone_name: str) -> dict:
         """Delete a DNS zone and all its records (permanent)."""
-        return self._client.delete(f"/api/v1/dashboard/dns/zones/{zone_name}")
+        return self._client.delete(f"/v1/dns/zones/{zone_name}")
 
     # ── Records ───────────────────────────────────────────────────
 
     def records(self, zone_name: str) -> list[dict]:
         """List all records in a DNS zone."""
-        data = self._client.get(f"/api/v1/dashboard/dns/zones/{zone_name}/records")
+        data = self._client.get(f"/v1/dns/zones/{zone_name}/records")
         return data.get("records", data) if isinstance(data, dict) else data
 
     def create_record(
@@ -58,10 +67,7 @@ class DNSService:
         }
         if priority is not None:
             body["priority"] = priority
-        return self._client.post(
-            f"/api/v1/dashboard/dns/zones/{zone_name}/records",
-            json=body,
-        )
+        return self._client.post(f"/v1/dns/zones/{zone_name}/records", json=body)
 
     def update_record(self, zone_name: str, record_id: str, **kwargs) -> dict:
         """Update a DNS record. Pass value=, ttl=, and/or priority= as kwargs."""
@@ -71,27 +77,22 @@ class DNSService:
         for key in ("ttl", "priority"):
             if key in kwargs and kwargs[key] is not None:
                 body[key] = kwargs[key]
-        return self._client.patch(
-            f"/api/v1/dashboard/dns/zones/{zone_name}/records/{record_id}",
-            json=body,
-        )
+        return self._client.put(f"/v1/dns/zones/{zone_name}/records/{record_id}", json=body)
 
     def delete_record(self, zone_name: str, record_id: str) -> dict:
         """Delete a DNS record (permanent)."""
-        return self._client.delete(
-            f"/api/v1/dashboard/dns/zones/{zone_name}/records/{record_id}"
-        )
+        return self._client.delete(f"/v1/dns/zones/{zone_name}/records/{record_id}")
 
     # ── DNSSEC ────────────────────────────────────────────────────
 
     def dnssec_status(self, zone_name: str) -> dict:
         """Get DNSSEC status for a zone."""
-        return self._client.get(f"/api/v1/dashboard/dns/zones/{zone_name}/dnssec")
+        return self._client.get(f"/v1/dns/zones/{zone_name}/dnssec")
 
     def dnssec_activate(self, zone_name: str) -> dict:
         """Activate DNSSEC for a zone."""
-        return self._client.post(f"/api/v1/dashboard/dns/zones/{zone_name}/dnssec/activate")
+        return self._client.post(f"/v1/dns/zones/{zone_name}/dnssec/activate")
 
     def dnssec_deactivate(self, zone_name: str) -> dict:
         """Deactivate DNSSEC for a zone."""
-        return self._client.post(f"/api/v1/dashboard/dns/zones/{zone_name}/dnssec/deactivate")
+        return self._client.delete(f"/v1/dns/zones/{zone_name}/dnssec")

{wayscloud-0.1.0 → wayscloud-0.2.3}/wayscloud/services/iot.py

@@ -6,21 +6,30 @@ from typing import Optional
 
 
 class IoTService:
-    """Manage IoT devices, groups, rules, and telemetry."""
+    """Manage IoT devices, groups, rules, and telemetry.
+
+    All methods use the public API at /v1/iot (API key auth).
+    """
 
     def __init__(self, client):
         self._client = client
 
     # ── Devices ───────────────────────────────────────────────────
 
-    def devices(self) -> list[dict]:
+    def list(self) -> list[dict]:
         """List all IoT devices."""
-        data = self._client.get("/api/v1/dashboard/iot/devices")
+        data = self._client.get("/v1/iot/devices")
         return data.get("devices", data) if isinstance(data, dict) else data
 
-    def get_device(self, device_id: str) -> dict:
+    # Alias for backward compatibility
+    devices = list
+
+    def get(self, device_id: str) -> dict:
         """Get details of a specific device."""
-        return self._client.get(f"/api/v1/dashboard/iot/devices/{device_id}")
+        return self._client.get(f"/v1/iot/devices/{device_id}")
+
+    # Alias
+    get_device = get
 
     def create_device(
         self,
@@ -28,56 +37,36 @@ class IoTService:
         name: str,
         device_type: Optional[str] = None,
     ) -> dict:
-        """Register a new IoT device.
-
-        Args:
-            device_id: Unique device identifier.
-            name: Human-readable device name.
-            device_type: Optional device type classification.
-        """
+        """Register a new IoT device."""
         body: dict = {"device_id": device_id, "name": name}
         if device_type:
             body["device_type"] = device_type
-        return self._client.post("/api/v1/dashboard/iot/devices", json=body)
+        return self._client.post("/v1/iot/devices", json=body)
 
     def update_device(self, device_id: str, **kwargs) -> dict:
         """Update a device. Pass name=, device_type=, and/or is_active= as kwargs."""
         body = {}
-        if "name" in kwargs:
-            body["name"] = kwargs["name"]
-        if "device_type" in kwargs:
-            body["device_type"] = kwargs["device_type"]
-        if "is_active" in kwargs:
-            body["is_active"] = kwargs["is_active"]
-        return self._client.patch(
-            f"/api/v1/dashboard/iot/devices/{device_id}",
-            json=body,
-        )
+        for key in ("name", "device_type", "is_active"):
+            if key in kwargs:
+                body[key] = kwargs[key]
+        return self._client.patch(f"/v1/iot/devices/{device_id}", json=body)
 
     def delete_device(self, device_id: str) -> dict:
         """Delete an IoT device."""
-        return self._client.delete(f"/api/v1/dashboard/iot/devices/{device_id}")
+        return self._client.delete(f"/v1/iot/devices/{device_id}")
 
-    def device_credentials(self, device_id: str) -> dict:
-        """Get MQTT credentials for a device.
-
-        Returns username, password, client_id, broker_url, and port.
-        """
-        return self._client.get(
-            f"/api/v1/dashboard/iot/devices/{device_id}/credentials"
-        )
+    # device_credentials() removed — no public /v1/iot endpoint.
+    # MQTT credentials are returned in the create_device() response.
 
     def device_telemetry(self, device_id: str) -> dict:
         """Get latest telemetry data for a device."""
-        return self._client.get(
-            f"/api/v1/dashboard/iot/devices/{device_id}/telemetry/latest"
-        )
+        return self._client.get(f"/v1/iot/devices/{device_id}/telemetry/latest")
 
     # ── Groups ────────────────────────────────────────────────────
 
     def groups(self) -> list[dict]:
         """List all device groups."""
-        data = self._client.get("/api/v1/dashboard/iot/groups")
+        data = self._client.get("/v1/iot/groups")
         return data.get("groups", data) if isinstance(data, dict) else data
 
     def create_group(self, name: str, description: Optional[str] = None) -> dict:
@@ -85,17 +74,17 @@ class IoTService:
         body: dict = {"name": name}
         if description:
             body["description"] = description
-        return self._client.post("/api/v1/dashboard/iot/groups", json=body)
+        return self._client.post("/v1/iot/groups", json=body)
 
     def delete_group(self, group_id: str) -> dict:
         """Delete a device group."""
-        return self._client.delete(f"/api/v1/dashboard/iot/groups/{group_id}")
+        return self._client.delete(f"/v1/iot/groups/{group_id}")
 
     # ── Rules ─────────────────────────────────────────────────────
 
     def rules(self) -> list[dict]:
         """List all IoT rules."""
-        data = self._client.get("/api/v1/dashboard/iot/rules")
+        data = self._client.get("/v1/iot/rules")
         return data.get("rules", data) if isinstance(data, dict) else data
 
     def create_rule(
@@ -104,28 +93,15 @@ class IoTService:
         rule_type: str,
         severity: str = "warning",
     ) -> dict:
-        """Create an IoT rule.
-
-        Args:
-            name: Rule name.
-            rule_type: Rule type.
-            severity: Severity level (default: warning).
-        """
+        """Create an IoT rule."""
         return self._client.post(
-            "/api/v1/dashboard/iot/rules",
+            "/v1/iot/rules",
             json={"name": name, "type": rule_type, "severity": severity},
         )
 
     def delete_rule(self, rule_id: str) -> dict:
         """Delete an IoT rule."""
-        return self._client.delete(f"/api/v1/dashboard/iot/rules/{rule_id}")
-
-    # ── Overview & Subscription ───────────────────────────────────
-
-    def overview(self) -> dict:
-        """Get IoT fleet overview."""
-        return self._client.get("/api/v1/dashboard/iot/overview")
+        return self._client.delete(f"/v1/iot/rules/{rule_id}")
 
-    def subscription(self) -> dict:
-        """Get IoT subscription info."""
-        return self._client.get("/api/v1/dashboard/iot/subscription")
+    # overview() and subscription() removed — no public /v1/iot equivalent.
+    # These are dashboard-only features.

wayscloud-0.2.3/wayscloud/services/redis.py

@@ -0,0 +1,77 @@
+"""Redis service -- Redis-as-a-Service management."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+
+class RedisService:
+    """Manage Redis instances.
+
+    All methods use the public API at /v1/redis (API key auth).
+    """
+
+    def __init__(self, client):
+        self._client = client
+
+    def list(self) -> list[dict]:
+        """List all Redis instances."""
+        data = self._client.get("/v1/redis/instances")
+        return data if isinstance(data, list) else data.get("instances", [])
+
+    def get(self, instance_id: str) -> dict:
+        """Get details of a specific Redis instance (includes connection info)."""
+        return self._client.get(f"/v1/redis/instances/{instance_id}")
+
+    def create(
+        self,
+        name: str,
+        plan: str = "redis-starter",
+        region: str = "no",
+    ) -> dict:
+        """Create a new Redis instance."""
+        return self._client.post(
+            "/v1/redis/instances",
+            json={"name": name, "plan": plan, "region": region},
+        )
+
+    def delete(self, instance_id: str) -> dict:
+        """Delete a Redis instance (permanent)."""
+        return self._client.delete(f"/v1/redis/instances/{instance_id}")
+
+    def restart(self, instance_id: str) -> dict:
+        """Restart a Redis instance."""
+        return self._client.post(f"/v1/redis/instances/{instance_id}:restart")
+
+    def plans(self) -> list[dict]:
+        """List available Redis plans."""
+        data = self._client.get("/v1/redis/plans")
+        return data if isinstance(data, list) else data.get("plans", [])
+
+    def regions(self) -> list[dict]:
+        """List available Redis regions."""
+        data = self._client.get("/v1/redis/regions")
+        return data if isinstance(data, list) else data.get("regions", [])
+
+    # credentials() removed — GET /instances/{id} includes connection info.
+    # Use rotate_credentials() to get new password.
+
+    def rotate_credentials(self, instance_id: str) -> dict:
+        """Rotate Redis credentials. Returns new password."""
+        return self._client.post(f"/v1/redis/instances/{instance_id}:rotate-credentials")
+
+    def firewall_rules(self, instance_id: str) -> list[dict]:
+        """List firewall rules for a Redis instance."""
+        data = self._client.get(f"/v1/redis/instances/{instance_id}/firewall")
+        return data if isinstance(data, list) else data.get("rules", [])
+
+    def add_firewall_rule(self, instance_id: str, source: str, description: str = "") -> dict:
+        """Add a firewall rule to allow access from a CIDR."""
+        return self._client.post(
+            f"/v1/redis/instances/{instance_id}/firewall",
+            json={"source": source, "description": description},
+        )
+
+    def remove_firewall_rule(self, instance_id: str, rule_id: str) -> dict:
+        """Remove a firewall rule."""
+        return self._client.delete(f"/v1/redis/instances/{instance_id}/firewall/{rule_id}")