devopness 2.7.2__tar.gz → 2.8.1__tar.gz

{devopness-2.7.2 → devopness-2.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devopness
-Version: 2.7.2
+Version: 2.8.1
 Summary: Devopness API Python SDK - Painless essential DevOps to everyone
 License-Expression: Apache-2.0
 Keywords: API Client,Cloud Engineering,Cloud Infrastructure,Cloud Platform,Cloud Resource Management,Configuration Management,Deployment Automation,Devopness,DevOps,Infrastructure as Code,Platform Engineering,Python SDK,Server Management,Server Provisioning,Zero Downtime Deployment
@@ -25,7 +25,7 @@ Classifier: Topic :: System :: Systems Administration
 Classifier: Topic :: Utilities
 Requires-Dist: httpcore (>=1.0.9)
 Requires-Dist: httpx (>=0.28.1,<0.29.0)
-Requires-Dist: pydantic (>=2.13.4,<3.0.0)
+Requires-Dist: pydantic (>=2.13.5,<3.0.0)
 Project-URL: Homepage, https://www.devopness.com
 Project-URL: Repository, https://github.com/devopness/devopness
 Description-Content-Type: text/markdown

{devopness-2.7.2 → devopness-2.8.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "devopness"
-version = "2.7.2"
+version = "2.8.1"
 description = "Devopness API Python SDK - Painless essential DevOps to everyone"
 license = "Apache-2.0"
 readme = "README.md"
@@ -53,7 +53,7 @@ dependencies = [
   # Related issue: https://github.com/devopness/devopness/security/dependabot/63
   "httpcore (>=1.0.9)",
   "httpx (>=0.28.1,<0.29.0)",
-  "pydantic (>=2.13.4,<3.0.0)",
+  "pydantic (>=2.13.5,<3.0.0)",
 ]
 
 [project.urls]
@@ -67,8 +67,8 @@ packages = [
 exclude = ["src/devopness/generated/.openapi-generator-ignore"]
 
 [tool.poetry.group.dev.dependencies]
-openapi-generator-cli = { version = "7.24.0", markers = "python_version < '4.0'" }
-ruff = "^0.16.4"
+openapi-generator-cli = { version = "7.25.0", markers = "python_version < '4.0'" }
+ruff = "^0.16.5"
 mypy = "^2.3.1"
 
 [tool.ruff]
@@ -108,6 +108,7 @@ ignore = [
   "line-too-long",                 # Line too long
   "non-pep604-annotation-union",   # Use `X | Y` for type annotations (auto-generated code uses Union)
   "builtin-argument-shadowing",    # Shadowing builtin argument
+  "replace-str-enum",              # Generated enums intentionally inherit from str and Enum
 ]
 "src/devopness/generated/**/__init__.py" = [
   "unused-import", # Module imported but unused

{devopness-2.7.2 → devopness-2.8.1}/src/devopness/base/__init__.py

@@ -3,10 +3,15 @@ Devopness API Python SDK - Painless essential DevOps to everyone
 """
 
 from .base_model import DevopnessBaseModel
-from .base_service import DevopnessBaseService, DevopnessBaseServiceAsync
+from .base_service import (
+    DevopnessBaseService,
+    DevopnessBaseServiceAsync,
+    DevopnessClientState,
+)
 
 __all__ = [
     "DevopnessBaseModel",
     "DevopnessBaseService",
     "DevopnessBaseServiceAsync",
+    "DevopnessClientState",
 ]

{devopness-2.7.2 → devopness-2.8.1}/src/devopness/base/base_service.py

@@ -7,10 +7,12 @@ from typing import Any
 
 import httpx
 
-from devopness.core.sdk_error import DevopnessSdkError
-
 from ..base import DevopnessBaseModel
 from ..client_config import DevopnessClientConfig
+from ..client_state import (
+    DEVOPNESS_CLIENT_STATE_EXTENSION_KEY,
+    DevopnessClientState,
+)
 from ..core.api_error import (
     raise_devopness_api_error,
     raise_devopness_api_error_sync,
@@ -19,10 +21,12 @@ from ..core.network_error import (
     handle_network_errors,
     handle_network_errors_sync,
 )
+from ..core.sdk_error import DevopnessSdkError
 
 __all__ = [
     "DevopnessBaseService",
     "DevopnessBaseServiceAsync",
+    "DevopnessClientState",
 ]
 
 
@@ -33,24 +37,22 @@ class DevopnessBaseService:
     """
 
     _client: httpx.Client
-    _config: DevopnessClientConfig
+    _state: DevopnessClientState
 
-    _access_token: str | None = None
-    _refresh_token: str | None = None
-    _token_expires_at: datetime | None = None
-
-    def __init__(self) -> None:
+    def __init__(self, state: DevopnessClientState | None = None) -> None:
         """
         Initializes the API base service with the provided configuration.
         """
-        if getattr(DevopnessBaseService, "_config", None) is None:
-            raise DevopnessSdkError("DevopnessBaseService is not initialized")
+        if state is None:
+            state = DevopnessClientState(config=DevopnessClientConfig())
+
+        self._state = state
 
         self._client = httpx.Client(
-            base_url=self._config.base_url,
-            timeout=self._config.timeout,
-            default_encoding=self._config.default_encoding,
-            headers=self._config.headers,
+            base_url=self._state.config.base_url,
+            timeout=self._state.config.timeout,
+            default_encoding=self._state.config.default_encoding,
+            headers=dict(self._state.config.headers),
             event_hooks={
                 "request": [self._on_request_callback],
                 "response": [self._on_response_callback],
@@ -119,7 +121,7 @@ class DevopnessBaseService:
         """
         response = self._post(
             "/users/refresh-token",
-            {"refresh_token": DevopnessBaseService._refresh_token},
+            {"refresh_token": self._state.refresh_token},
         )
 
         self._save_access_token(response)
@@ -138,9 +140,9 @@ class DevopnessBaseService:
         expires_in: int = data["expires_in"]
         expires_at = now + timedelta(seconds=expires_in)
 
-        DevopnessBaseService._access_token = data["access_token"]
-        DevopnessBaseService._refresh_token = data["refresh_token"]
-        DevopnessBaseService._token_expires_at = expires_at
+        self._state.access_token = data["access_token"]
+        self._state.refresh_token = data["refresh_token"]
+        self._state.token_expires_at = expires_at
 
     def _on_request_callback(self, request: httpx.Request) -> None:
         """
@@ -150,15 +152,17 @@ class DevopnessBaseService:
         Args:
             request (httpx.Request): The outgoing HTTP request.
         """
+        request.extensions[DEVOPNESS_CLIENT_STATE_EXTENSION_KEY] = self._state
+
         if (
-            DevopnessBaseService._config.auto_refresh_token
-            and is_access_token_expired(DevopnessBaseService)
+            self._state.config.auto_refresh_token
+            and is_access_token_expired(self._state)
             and not is_token_change_request(request.url.path)
         ):
             self._refresh_access_token()
 
-        api_token = DevopnessBaseService._config.api_token
-        access_token = DevopnessBaseService._access_token
+        api_token = self._state.config.api_token
+        access_token = self._state.access_token
 
         if api_token:
             request.headers["Authorization"] = f"Bearer {api_token}"
@@ -169,7 +173,7 @@ class DevopnessBaseService:
         elif "Authorization" in request.headers:
             del request.headers["Authorization"]
 
-        if DevopnessBaseService._config.debug:
+        if self._state.config.debug:
             debug_request(request)
 
     def _on_response_callback(self, response: httpx.Response) -> httpx.Response:
@@ -185,13 +189,12 @@ class DevopnessBaseService:
         try:
             response.raise_for_status()
 
-            if (
-                DevopnessBaseService._config.auto_refresh_token
-                and is_token_change_request(response.url.path)
+            if self._state.config.auto_refresh_token and is_token_change_request(
+                response.url.path
             ):
                 self._save_access_token(response)
 
-            if DevopnessBaseService._config.debug:
+            if self._state.config.debug:
                 debug_response(response)
 
         except httpx.HTTPStatusError as e:
@@ -207,24 +210,22 @@ class DevopnessBaseServiceAsync:
     """
 
     _client: httpx.AsyncClient
-    _config: DevopnessClientConfig
-
-    _access_token: str | None = None
-    _refresh_token: str | None = None
-    _token_expires_at: datetime | None = None
+    _state: DevopnessClientState
 
-    def __init__(self) -> None:
+    def __init__(self, state: DevopnessClientState | None = None) -> None:
         """
         Initializes the API base service with the provided configuration.
         """
-        if getattr(DevopnessBaseServiceAsync, "_config", None) is None:
-            raise DevopnessSdkError("DevopnessBaseServiceAsync is not initialized")
+        if state is None:
+            state = DevopnessClientState(config=DevopnessClientConfig())
+
+        self._state = state
 
         self._client = httpx.AsyncClient(
-            base_url=self._config.base_url,
-            timeout=self._config.timeout,
-            default_encoding=self._config.default_encoding,
-            headers=self._config.headers,
+            base_url=self._state.config.base_url,
+            timeout=self._state.config.timeout,
+            default_encoding=self._state.config.default_encoding,
+            headers=dict(self._state.config.headers),
             event_hooks={
                 "request": [self._on_request_callback],
                 "response": [self._on_response_callback],
@@ -293,7 +294,7 @@ class DevopnessBaseServiceAsync:
         """
         response = await self._post(
             "/users/refresh-token",
-            {"refresh_token": DevopnessBaseServiceAsync._refresh_token},
+            {"refresh_token": self._state.refresh_token},
         )
 
         await self._save_access_token(response)
@@ -312,9 +313,9 @@ class DevopnessBaseServiceAsync:
         expires_in: int = data["expires_in"]
         expires_at = now + timedelta(seconds=expires_in)
 
-        DevopnessBaseServiceAsync._access_token = data["access_token"]
-        DevopnessBaseServiceAsync._refresh_token = data["refresh_token"]
-        DevopnessBaseServiceAsync._token_expires_at = expires_at
+        self._state.access_token = data["access_token"]
+        self._state.refresh_token = data["refresh_token"]
+        self._state.token_expires_at = expires_at
 
     async def _on_request_callback(self, request: httpx.Request) -> None:
         """
@@ -324,15 +325,17 @@ class DevopnessBaseServiceAsync:
         Args:
             request (httpx.Request): The outgoing HTTP request.
         """
+        request.extensions[DEVOPNESS_CLIENT_STATE_EXTENSION_KEY] = self._state
+
         if (
-            DevopnessBaseServiceAsync._config.auto_refresh_token
-            and is_access_token_expired(DevopnessBaseServiceAsync)
+            self._state.config.auto_refresh_token
+            and is_access_token_expired(self._state)
             and not is_token_change_request(request.url.path)
         ):
             await self._refresh_access_token()
 
-        api_token = DevopnessBaseServiceAsync._config.api_token
-        access_token = DevopnessBaseServiceAsync._access_token
+        api_token = self._state.config.api_token
+        access_token = self._state.access_token
 
         if api_token:
             request.headers["Authorization"] = f"Bearer {api_token}"
@@ -343,7 +346,7 @@ class DevopnessBaseServiceAsync:
         elif "Authorization" in request.headers:
             del request.headers["Authorization"]
 
-        if DevopnessBaseServiceAsync._config.debug:
+        if self._state.config.debug:
             debug_request(request)
 
     async def _on_response_callback(self, response: httpx.Response) -> httpx.Response:
@@ -359,13 +362,12 @@ class DevopnessBaseServiceAsync:
         try:
             response.raise_for_status()
 
-            if (
-                DevopnessBaseServiceAsync._config.auto_refresh_token
-                and is_token_change_request(response.url.path)
+            if self._state.config.auto_refresh_token and is_token_change_request(
+                response.url.path
             ):
                 await self._save_access_token(response)
 
-            if DevopnessBaseServiceAsync._config.debug:
+            if self._state.config.debug:
                 debug_response(response)
 
         except httpx.HTTPStatusError as e:
@@ -400,13 +402,11 @@ def debug_response(response: httpx.Response) -> None:
     print(f"[Devopness SDK] <-- [Response] {r_status_code} {r_reason_phrase}")
 
 
-def is_access_token_expired(
-    service_cls: type[DevopnessBaseService] | type[DevopnessBaseServiceAsync],
-) -> bool:
+def is_access_token_expired(state: DevopnessClientState) -> bool:
     """
     Checks if the access token has expired.
     """
-    expires_at = service_cls._token_expires_at
+    expires_at = state.token_expires_at
     if expires_at is None:
         return True
 

{devopness-2.7.2 → devopness-2.8.1}/src/devopness/client.py

@@ -2,10 +2,7 @@
 Devopness API Python SDK - Painless essential DevOps to everyone
 """
 
-from .base import (
-    DevopnessBaseService,
-    DevopnessBaseServiceAsync,
-)
+from .base import DevopnessClientState
 from .client_config import (
     DevopnessClientConfig,
     DevopnessClientConfigDict,
@@ -159,56 +156,82 @@ class DevopnessClient:
         self,
         config: DevopnessClientConfig | DevopnessClientConfigDict | None = None,
     ) -> None:
+        """
+        Build a synchronous Devopness client with isolated per-instance state.
+        """
+        self._state = self._build_state(config)
+
+        self.actions = ActionService(self._state)
+        self.api_tokens = APITokenService(self._state)
+        self.applications = ApplicationService(self._state)
+        self.credentials = CredentialService(self._state)
+        self.cron_jobs = CronJobService(self._state)
+        self.daemons = DaemonService(self._state)
+        self.environments = EnvironmentService(self._state)
+        self.hooks = HookService(self._state)
+        self.network_rules = NetworkRuleService(self._state)
+        self.networks = NetworkService(self._state)
+        self.organizations = OrganizationService(self._state)
+        self.pipelines = PipelineService(self._state)
+        self.projects = ProjectService(self._state)
+        self.resource_events = ResourceEventService(self._state)
+        self.resource_links = ResourceLinkService(self._state)
+        self.roles = RoleService(self._state)
+        self.servers = ServerService(self._state)
+        self.services = ServiceService(self._state)
+        self.social_accounts = SocialAccountService(self._state)
+        self.ssh_keys = SSHKeyService(self._state)
+        self.ssl_certificates = SSLCertificateService(self._state)
+        self.static = StaticService(self._state)
+        self.subnets = SubnetService(self._state)
+        self.teams = TeamService(self._state)
+        self.users = UserService(self._state)
+        self.variables = VariableService(self._state)
+        self.virtual_hosts = VirtualHostService(self._state)
+
+    @staticmethod
+    def _build_state(
+        config: DevopnessClientConfig | DevopnessClientConfigDict | None,
+    ) -> DevopnessClientState:
+        """
+        Normalize user input into an isolated client state object.
+        """
         if config is None:
-            config = DevopnessClientConfig()
+            normalized_config = DevopnessClientConfig()
         elif isinstance(config, dict):
-            config = DevopnessClientConfig.from_dict(config)
-
-        DevopnessBaseService._config = config
+            normalized_config = DevopnessClientConfig.from_dict(config)
+        else:
+            normalized_config = config
 
-        self.actions = ActionService()
-        self.api_tokens = APITokenService()
-        self.applications = ApplicationService()
-        self.credentials = CredentialService()
-        self.cron_jobs = CronJobService()
-        self.daemons = DaemonService()
-        self.environments = EnvironmentService()
-        self.hooks = HookService()
-        self.network_rules = NetworkRuleService()
-        self.networks = NetworkService()
-        self.organizations = OrganizationService()
-        self.pipelines = PipelineService()
-        self.projects = ProjectService()
-        self.resource_events = ResourceEventService()
-        self.resource_links = ResourceLinkService()
-        self.roles = RoleService()
-        self.servers = ServerService()
-        self.services = ServiceService()
-        self.social_accounts = SocialAccountService()
-        self.ssh_keys = SSHKeyService()
-        self.ssl_certificates = SSLCertificateService()
-        self.static = StaticService()
-        self.subnets = SubnetService()
-        self.teams = TeamService()
-        self.users = UserService()
-        self.variables = VariableService()
-        self.virtual_hosts = VirtualHostService()
+        normalized_config = normalized_config.model_copy(deep=True)
+        state = DevopnessClientState(config=normalized_config)
+        return state
 
     def __set_api_token(self, api_token: str) -> None:
-        # pylint: disable=protected-access
-        DevopnessBaseService._config.api_token = api_token
+        """
+        Update the API token for this client instance.
+        """
+        self._state.config.api_token = api_token
 
     def __get_api_token(self) -> str | None:
-        # pylint: disable=protected-access
-        return DevopnessBaseService._config.api_token
+        """
+        Return the API token for this client instance.
+        """
+        api_token = self._state.config.api_token
+        return api_token
 
     def __set_access_token(self, access_token: str) -> None:
-        # pylint: disable=protected-access
-        DevopnessBaseService._access_token = access_token
+        """
+        Update the access token for this client instance.
+        """
+        self._state.access_token = access_token
 
     def __get_access_token(self) -> str | None:
-        # pylint: disable=protected-access
-        return DevopnessBaseService._access_token
+        """
+        Return the access token for this client instance.
+        """
+        access_token = self._state.access_token
+        return access_token
 
     api_token = property(fset=__set_api_token, fget=__get_api_token)
     access_token = property(fset=__set_access_token, fget=__get_access_token)
@@ -251,56 +274,50 @@ class DevopnessClientAsync:
         self,
         config: DevopnessClientConfig | DevopnessClientConfigDict | None = None,
     ) -> None:
-        if config is None:
-            config = DevopnessClientConfig()
-        elif isinstance(config, dict):
-            config = DevopnessClientConfig.from_dict(config)
-
-        DevopnessBaseServiceAsync._config = config
+        """
+        Build an asynchronous Devopness client with isolated per-instance state.
+        """
+        self._state = DevopnessClient._build_state(config)
 
-        self.actions = ActionServiceAsync()
-        self.api_tokens = APITokenServiceAsync()
-        self.applications = ApplicationServiceAsync()
-        self.credentials = CredentialServiceAsync()
-        self.cron_jobs = CronJobServiceAsync()
-        self.daemons = DaemonServiceAsync()
-        self.environments = EnvironmentServiceAsync()
-        self.hooks = HookServiceAsync()
-        self.network_rules = NetworkRuleServiceAsync()
-        self.networks = NetworkServiceAsync()
-        self.organizations = OrganizationServiceAsync()
-        self.pipelines = PipelineServiceAsync()
-        self.projects = ProjectServiceAsync()
-        self.resource_events = ResourceEventServiceAsync()
-        self.resource_links = ResourceLinkServiceAsync()
-        self.roles = RoleServiceAsync()
-        self.servers = ServerServiceAsync()
-        self.services = ServiceServiceAsync()
-        self.social_accounts = SocialAccountServiceAsync()
-        self.ssh_keys = SSHKeyServiceAsync()
-        self.ssl_certificates = SSLCertificateServiceAsync()
-        self.static = StaticServiceAsync()
-        self.subnets = SubnetServiceAsync()
-        self.teams = TeamServiceAsync()
-        self.users = UserServiceAsync()
-        self.variables = VariableServiceAsync()
-        self.virtual_hosts = VirtualHostServiceAsync()
+        self.actions = ActionServiceAsync(self._state)
+        self.api_tokens = APITokenServiceAsync(self._state)
+        self.applications = ApplicationServiceAsync(self._state)
+        self.credentials = CredentialServiceAsync(self._state)
+        self.cron_jobs = CronJobServiceAsync(self._state)
+        self.daemons = DaemonServiceAsync(self._state)
+        self.environments = EnvironmentServiceAsync(self._state)
+        self.hooks = HookServiceAsync(self._state)
+        self.network_rules = NetworkRuleServiceAsync(self._state)
+        self.networks = NetworkServiceAsync(self._state)
+        self.organizations = OrganizationServiceAsync(self._state)
+        self.pipelines = PipelineServiceAsync(self._state)
+        self.projects = ProjectServiceAsync(self._state)
+        self.resource_events = ResourceEventServiceAsync(self._state)
+        self.resource_links = ResourceLinkServiceAsync(self._state)
+        self.roles = RoleServiceAsync(self._state)
+        self.servers = ServerServiceAsync(self._state)
+        self.services = ServiceServiceAsync(self._state)
+        self.social_accounts = SocialAccountServiceAsync(self._state)
+        self.ssh_keys = SSHKeyServiceAsync(self._state)
+        self.ssl_certificates = SSLCertificateServiceAsync(self._state)
+        self.static = StaticServiceAsync(self._state)
+        self.subnets = SubnetServiceAsync(self._state)
+        self.teams = TeamServiceAsync(self._state)
+        self.users = UserServiceAsync(self._state)
+        self.variables = VariableServiceAsync(self._state)
+        self.virtual_hosts = VirtualHostServiceAsync(self._state)
 
     def __set_api_token(self, api_token: str) -> None:
-        # pylint: disable=protected-access
-        DevopnessBaseServiceAsync._config.api_token = api_token
+        self._state.config.api_token = api_token
 
     def __get_api_token(self) -> str | None:
-        # pylint: disable=protected-access
-        return DevopnessBaseServiceAsync._config.api_token
+        return self._state.config.api_token
 
     def __set_access_token(self, access_token: str) -> None:
-        # pylint: disable=protected-access
-        DevopnessBaseServiceAsync._access_token = access_token
+        self._state.access_token = access_token
 
     def __get_access_token(self) -> str | None:
-        # pylint: disable=protected-access
-        return DevopnessBaseServiceAsync._access_token
+        return self._state.access_token
 
     api_token = property(fset=__set_api_token, fget=__get_api_token)
     access_token = property(fset=__set_access_token, fget=__get_access_token)

devopness-2.8.1/src/devopness/client_state.py

@@ -0,0 +1,27 @@
+"""
+Devopness API Python SDK - Painless essential DevOps to everyone
+"""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .client_config import DevopnessClientConfig
+
+DEVOPNESS_CLIENT_STATE_EXTENSION_KEY = "devopness_client_state"
+
+
+@dataclass
+class DevopnessClientState:
+    """
+    Per-client runtime state for Devopness SDK instances.
+
+    This groups the immutable client configuration with mutable runtime data
+    such as access tokens and token expiration timestamps.
+    """
+
+    config: "DevopnessClientConfig"
+    access_token: str | None = None
+    refresh_token: str | None = None
+    token_expires_at: datetime | None = None

{devopness-2.7.2 → devopness-2.8.1}/src/devopness/core/api_error.py

@@ -76,15 +76,18 @@ class DevopnessApiError(DevopnessSdkError):
         if self.request_method and self.request_url:
             lines.append(f"Request: {self.request_method} {self.request_url}")
 
-        lines.append(f"Status Code: {self.status_code}")
-        lines.append(f"Message: {self.message}")
+        lines.extend(
+            [
+                f"Status Code: {self.status_code}",
+                f"Message: {self.message}",
+            ]
+        )
 
         if self.errors:
             lines.append("Errors:")
 
             for field, errors in self.errors.items():
-                lines.append(f"  - {field}:")
-                lines.extend(f"      {error}" for error in errors)
+                lines.extend([f"  - {field}:", *[f"      {error}" for error in errors]])
 
         return "\n".join(lines)