devopness 2.7.2__tar.gz → 2.8.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devopness
-Version: 2.7.2
+Version: 2.8.0
 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

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

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "devopness"
-version = "2.7.2"
+version = "2.8.0"
 description = "Devopness API Python SDK - Painless essential DevOps to everyone"
 license = "Apache-2.0"
 readme = "README.md"

{devopness-2.7.2 → devopness-2.8.0}/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.0}/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.0}/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.0/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.0}/src/devopness/core/response.py

@@ -3,7 +3,6 @@ Devopness API Python SDK - Painless essential DevOps to everyone
 """
 
 import json
-import sys
 from typing import Any, Generic, TypeVar, cast, get_args, get_origin
 from urllib.parse import parse_qs, urlparse
 from warnings import warn
@@ -12,6 +11,7 @@ import httpx
 from pydantic import ValidationError
 
 from devopness.base import DevopnessBaseModel
+from devopness.client_state import DEVOPNESS_CLIENT_STATE_EXTENSION_KEY
 
 __all__ = ["DevopnessResponse"]
 
@@ -48,6 +48,7 @@ class DevopnessResponse(Generic[T]):
     data: T
     page_count: int
     action_id: int | None
+    _config: object | None
 
     def __init__(
         self,
@@ -66,6 +67,7 @@ class DevopnessResponse(Generic[T]):
         """
         self._is_async_response = False
         self.status = response.status_code
+        self._config = self._extract_config(response)
         self.data = cast(T, self._parse_data(response, model_cls))
         self.page_count = self._extract_last_page_number(response)
         self.action_id = self._parse_action_id(response)
@@ -90,6 +92,7 @@ class DevopnessResponse(Generic[T]):
 
         result._is_async_response = True
         result.status = response.status_code
+        result._config = result._extract_config(response)
         result.data = cast(T, await result._async_parse_data(response, model_cls))
         result.page_count = result._extract_last_page_number(response)
         result.action_id = result._parse_action_id(response)
@@ -276,22 +279,39 @@ class DevopnessResponse(Generic[T]):
     def _model_name(model_cls: type[DevopnessBaseModel] | type | None) -> str:
         return getattr(model_cls, "__name__", repr(model_cls)) if model_cls else "None"
 
-    def _config(self) -> object | None:
-        base_service_module = sys.modules.get("devopness.base.base_service")
-        service_name = (
-            "DevopnessBaseServiceAsync"
-            if self._is_async_response
-            else "DevopnessBaseService"
-        )
-        service = getattr(base_service_module, service_name, None)
+    def _extract_config(self, response: httpx.Response) -> object | None:
+        """
+        Extract the client config attached to the originating request.
+        """
+        config: object | None = None
+        request: httpx.Request | None
+
+        try:
+            request = response.request
+        except RuntimeError:
+            request = None
+
+        if request is not None:
+            extensions = getattr(request, "extensions", None)
+            if isinstance(extensions, dict):
+                state = extensions.get(DEVOPNESS_CLIENT_STATE_EXTENSION_KEY)
+                config = getattr(state, "config", None)
 
-        return getattr(service, "_config", None)
+        return config
 
     def _is_strict_validation_mode(self) -> bool:
-        return getattr(self._config(), "strict_validation_mode", True)
+        """
+        Check whether response validation should raise on model mismatch.
+        """
+        strict_validation_mode = getattr(self._config, "strict_validation_mode", True)
+        return strict_validation_mode
 
     def _is_debug_mode(self) -> bool:
-        return getattr(self._config(), "debug", False)
+        """
+        Check whether debug warnings should be emitted during parsing.
+        """
+        debug_mode = getattr(self._config, "debug", False)
+        return debug_mode
 
     @staticmethod
     def _safe_validation_error_details(error: ValidationError) -> str: