stackmachine 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

stackmachine/__init__.py

@@ -2,9 +2,71 @@
 
 from importlib.metadata import PackageNotFoundError, version
 
+from ._async_client import AsyncStackMachine
+from ._client import StackMachine
+from ._config import RequestOptions
+from ._errors import (
+    StackMachineAPIError,
+    StackMachineAuthenticationError,
+    StackMachineConnectionError,
+    StackMachineError,
+    StackMachineGraphQLError,
+    StackMachineInvalidRequestError,
+    StackMachinePermissionError,
+    StackMachineRateLimitError,
+    StackMachineValidationError,
+    is_stackmachine_error,
+)
+from ._models import (
+    AppAlias,
+    AppSshServer,
+    DeployApp,
+    DeployAppKindWordPress,
+    DeployAppVersion,
+    DeploymentProgress,
+    ExpectedDNSRecord,
+    Log,
+    SshAuthorizedKey,
+    SshUser,
+    UploadProgress,
+    Viewer,
+)
+from ._pagination import AsyncStackMachineList, StackMachineList
+from ._uploads import create_zip
+
 try:
     __version__ = version("stackmachine")
 except PackageNotFoundError:
-    __version__ = "0.0.0"
+    __version__ = "0.3.0"
 
-__all__ = ["__version__"]
+__all__ = [
+    "AppAlias",
+    "AppSshServer",
+    "AsyncStackMachine",
+    "AsyncStackMachineList",
+    "DeployApp",
+    "DeployAppKindWordPress",
+    "DeployAppVersion",
+    "DeploymentProgress",
+    "ExpectedDNSRecord",
+    "Log",
+    "RequestOptions",
+    "SshAuthorizedKey",
+    "SshUser",
+    "StackMachine",
+    "StackMachineAPIError",
+    "StackMachineAuthenticationError",
+    "StackMachineConnectionError",
+    "StackMachineError",
+    "StackMachineGraphQLError",
+    "StackMachineInvalidRequestError",
+    "StackMachineList",
+    "StackMachinePermissionError",
+    "StackMachineRateLimitError",
+    "StackMachineValidationError",
+    "UploadProgress",
+    "Viewer",
+    "__version__",
+    "create_zip",
+    "is_stackmachine_error",
+]

stackmachine/_async_client.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+from typing import Any, Mapping, Optional
+
+import httpx
+
+from ._config import (
+    DEFAULT_API_URL,
+    DEFAULT_MAX_NETWORK_RETRIES,
+    DEFAULT_TIMEOUT,
+    ClientConfig,
+)
+from ._graphql import operations as gql
+from ._models import Viewer
+from ._transport import AsyncTransport
+from ._uploads import AsyncUploader
+from .resources.apps import AsyncDeployAppsResource
+from .resources.deployments import AsyncDeploymentsResource
+from .resources.files import AsyncFilesResource
+
+
+class AsyncStackMachine:
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        api_url: str = DEFAULT_API_URL,
+        headers: Optional[Mapping[str, str]] = None,
+        timeout: float = DEFAULT_TIMEOUT,
+        max_network_retries: int = DEFAULT_MAX_NETWORK_RETRIES,
+        http_client: Optional[httpx.AsyncClient] = None,
+        http_transport: Optional[httpx.AsyncBaseTransport] = None,
+    ) -> None:
+        self.api_key = api_key
+        self.api_url = api_url
+        self.apiUrl = api_url
+        self.timeout = timeout
+        self.max_network_retries = max_network_retries
+        self.maxNetworkRetries = max_network_retries
+        self._config = ClientConfig(
+            api_url=api_url,
+            headers=headers,
+            timeout=timeout,
+            max_network_retries=max_network_retries,
+        )
+        self._transport = AsyncTransport(
+            api_key,
+            self._config,
+            http_client=http_client,
+            http_transport=http_transport,
+        )
+        self.deployments = AsyncDeploymentsResource(self)
+        self.apps = AsyncDeployAppsResource(self, self.deployments)
+        self.files = AsyncFilesResource(self, AsyncUploader(self._transport))
+
+    @classmethod
+    def init(
+        cls,
+        settings: Optional[Mapping[str, Any]] = None,
+        **kwargs: Any,
+    ) -> "AsyncStackMachine":
+        values = {**dict(settings or {}), **kwargs}
+        api_key = values.pop("api_key", None) or values.pop("token", None) or ""
+        if "apiUrl" in values:
+            values["api_url"] = values.pop("apiUrl")
+        if "maxNetworkRetries" in values:
+            values["max_network_retries"] = values.pop("maxNetworkRetries")
+        return cls(api_key, **values)
+
+    async def close(self) -> None:
+        await self._transport.close()
+
+    async def __aenter__(self) -> "AsyncStackMachine":
+        return self
+
+    async def __aexit__(self, *exc_info: object) -> None:
+        await self.close()
+
+    async def _query(
+        self,
+        query: str,
+        variables: Optional[Mapping[str, Any]] = None,
+        *,
+        request_options: Optional[Mapping[str, Any]] = None,
+    ) -> Any:
+        return await self._transport.execute(
+            query,
+            variables,
+            request_options=request_options,
+        )
+
+    async def _mutation(
+        self,
+        query: str,
+        variables: Optional[Mapping[str, Any]] = None,
+        *,
+        request_options: Optional[Mapping[str, Any]] = None,
+    ) -> Any:
+        return await self._transport.execute(
+            query,
+            variables,
+            request_options=request_options,
+            mutation=True,
+        )
+
+    def _subscribe_deployment(
+        self, build_id: str, request_options: Optional[Mapping[str, Any]] = None
+    ):
+        return self._transport.subscribe(
+            gql.AUTOBUILD_SUBSCRIPTION,
+            {"buildId": build_id},
+            request_options=request_options,
+        )
+
+    async def viewer(
+        self, *, request_options: Optional[Mapping[str, Any]] = None
+    ) -> Optional[Viewer]:
+        response = await self._query(
+            gql.VIEWER_QUERY, {}, request_options=request_options
+        )
+        viewer = response.get("viewer") if response else None
+        return Viewer(username=viewer["username"]) if viewer else None

stackmachine/_client.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from typing import Any, Mapping, Optional
+
+import httpx
+
+from ._config import (
+    DEFAULT_API_URL,
+    DEFAULT_MAX_NETWORK_RETRIES,
+    DEFAULT_TIMEOUT,
+    ClientConfig,
+)
+from ._graphql import operations as gql
+from ._models import Viewer
+from ._transport import SyncTransport
+from ._uploads import SyncUploader
+from .resources.apps import DeployAppsResource
+from .resources.deployments import DeploymentsResource
+from .resources.files import FilesResource
+
+
+class StackMachine:
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        api_url: str = DEFAULT_API_URL,
+        headers: Optional[Mapping[str, str]] = None,
+        timeout: float = DEFAULT_TIMEOUT,
+        max_network_retries: int = DEFAULT_MAX_NETWORK_RETRIES,
+        http_client: Optional[httpx.Client] = None,
+        http_transport: Optional[httpx.BaseTransport] = None,
+    ) -> None:
+        self.api_key = api_key
+        self.api_url = api_url
+        self.apiUrl = api_url
+        self.timeout = timeout
+        self.max_network_retries = max_network_retries
+        self.maxNetworkRetries = max_network_retries
+        self._config = ClientConfig(
+            api_url=api_url,
+            headers=headers,
+            timeout=timeout,
+            max_network_retries=max_network_retries,
+        )
+        self._transport = SyncTransport(
+            api_key,
+            self._config,
+            http_client=http_client,
+            http_transport=http_transport,
+        )
+        self.deployments = DeploymentsResource(self)
+        self.apps = DeployAppsResource(self, self.deployments)
+        self.files = FilesResource(self, SyncUploader(self._transport))
+
+    @classmethod
+    def init(
+        cls,
+        settings: Optional[Mapping[str, Any]] = None,
+        **kwargs: Any,
+    ) -> "StackMachine":
+        values = {**dict(settings or {}), **kwargs}
+        api_key = values.pop("api_key", None) or values.pop("token", None) or ""
+        if "apiUrl" in values:
+            values["api_url"] = values.pop("apiUrl")
+        if "maxNetworkRetries" in values:
+            values["max_network_retries"] = values.pop("maxNetworkRetries")
+        return cls(api_key, **values)
+
+    def close(self) -> None:
+        self._transport.close()
+
+    def __enter__(self) -> "StackMachine":
+        return self
+
+    def __exit__(self, *exc_info: object) -> None:
+        self.close()
+
+    def _query(
+        self,
+        query: str,
+        variables: Optional[Mapping[str, Any]] = None,
+        *,
+        request_options: Optional[Mapping[str, Any]] = None,
+    ) -> Any:
+        return self._transport.execute(
+            query,
+            variables,
+            request_options=request_options,
+        )
+
+    def _mutation(
+        self,
+        query: str,
+        variables: Optional[Mapping[str, Any]] = None,
+        *,
+        request_options: Optional[Mapping[str, Any]] = None,
+    ) -> Any:
+        return self._transport.execute(
+            query,
+            variables,
+            request_options=request_options,
+            mutation=True,
+        )
+
+    def _subscribe_deployment(
+        self, build_id: str, request_options: Optional[Mapping[str, Any]] = None
+    ):
+        return self._transport.subscribe(
+            gql.AUTOBUILD_SUBSCRIPTION,
+            {"buildId": build_id},
+            request_options=request_options,
+        )
+
+    def viewer(
+        self, *, request_options: Optional[Mapping[str, Any]] = None
+    ) -> Optional[Viewer]:
+        response = self._query(gql.VIEWER_QUERY, {}, request_options=request_options)
+        viewer = response.get("viewer") if response else None
+        return Viewer(username=viewer["username"]) if viewer else None

stackmachine/_config.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Mapping, Optional
+
+DEFAULT_API_URL = "https://api.stackmachine.com/graphql"
+DEFAULT_TIMEOUT = 80.0
+DEFAULT_MAX_NETWORK_RETRIES = 1
+
+
+@dataclass
+class RequestOptions:
+    api_key: Optional[str] = None
+    headers: Optional[Mapping[str, str]] = None
+    timeout: Optional[float] = None
+    max_network_retries: Optional[int] = None
+    idempotency_key: Optional[str] = None
+    client_mutation_id: Optional[str] = None
+    force: Optional[bool] = None
+
+
+@dataclass
+class ClientConfig:
+    api_url: str = DEFAULT_API_URL
+    headers: Optional[Mapping[str, str]] = None
+    timeout: float = DEFAULT_TIMEOUT
+    max_network_retries: int = DEFAULT_MAX_NETWORK_RETRIES

stackmachine/_errors.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from typing import Any, Mapping, Optional, Sequence
+
+GraphQLErrorPayload = Mapping[str, Any]
+
+
+class StackMachineError(Exception):
+    """Base exception raised by the StackMachine SDK."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        operation_name: Optional[str] = None,
+        status_code: Optional[int] = None,
+        request_id: Optional[str] = None,
+        code: Optional[str] = None,
+        param: Optional[str] = None,
+        graphql_errors: Optional[Sequence[GraphQLErrorPayload]] = None,
+        cause: Optional[BaseException] = None,
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.type = type(self).__name__
+        self.operation_name = operation_name
+        self.status_code = status_code
+        self.request_id = request_id
+        self.code = code
+        self.param = param
+        self.graphql_errors = graphql_errors
+        self.__cause__ = cause
+
+
+class StackMachineConnectionError(StackMachineError):
+    pass
+
+
+class StackMachineAPIError(StackMachineError):
+    pass
+
+
+class StackMachineGraphQLError(StackMachineError):
+    pass
+
+
+class StackMachineAuthenticationError(StackMachineAPIError):
+    pass
+
+
+class StackMachinePermissionError(StackMachineAPIError):
+    pass
+
+
+class StackMachineRateLimitError(StackMachineAPIError):
+    pass
+
+
+class StackMachineInvalidRequestError(StackMachineAPIError):
+    pass
+
+
+class StackMachineValidationError(StackMachineError):
+    pass
+
+
+def is_stackmachine_error(error: BaseException) -> bool:
+    return isinstance(error, StackMachineError)
+
+
+def stackmachine_error_from_graphql_errors(
+    graphql_errors: Sequence[GraphQLErrorPayload],
+    operation_name: Optional[str] = None,
+) -> StackMachineGraphQLError:
+    first = graphql_errors[0] if graphql_errors else {}
+    extensions = first.get("extensions") if isinstance(first, Mapping) else None
+    message = first.get("message") if isinstance(first, Mapping) else None
+    return StackMachineGraphQLError(
+        str(message or "StackMachine GraphQL request failed."),
+        operation_name=operation_name,
+        graphql_errors=graphql_errors,
+        code=extensions.get("code") if isinstance(extensions, Mapping) else None,
+        param=extensions.get("param") if isinstance(extensions, Mapping) else None,
+    )
+
+
+def stackmachine_error_from_unknown(
+    error: BaseException,
+    operation_name: Optional[str] = None,
+) -> StackMachineError:
+    if isinstance(error, StackMachineError):
+        return error
+    return StackMachineConnectionError(
+        str(error) or "StackMachine request failed.",
+        operation_name=operation_name,
+        cause=error,
+    )

stackmachine/_graphql/__init__.py

@@ -0,0 +1 @@
+from .operations import *  # noqa: F403