devopness 2.4.1__tar.gz → 2.5.0__tar.gz

{devopness-2.4.1 → devopness-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devopness
-Version: 2.4.1
+Version: 2.5.0
 Summary: Devopness API Python SDK - Painless essential DevOps to everyone
 License-Expression: MIT
 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
@@ -113,6 +113,31 @@ Configuration options:
 | `base_url`           | `https://api.devopness.com` | Base URL for all API requests                       |
 | `timeout`            | `30`                        | Timeout for HTTP requests (in seconds)              |
 | `default_encoding`   | `utf-8`                     | Encoding for response content                       |
+| `debug`              | `False`                     | Prints HTTP debug output and validation warnings    |
+| `strict_validation_mode` | `True`                  | Raises Pydantic validation errors for API responses |
+
+
+#### Response validation mode
+
+The SDK validates API responses against generated Pydantic models by default. This
+strict behavior helps surface mismatches between the API response and the documented
+contract. Consumers that must keep running when a response does not match the model
+can opt out by setting `strict_validation_mode=False`:
+
+```python
+from devopness import DevopnessClient, DevopnessClientConfig
+
+config = DevopnessClientConfig(
+    strict_validation_mode=False,
+    debug=True,
+)
+devopness = DevopnessClient(config)
+```
+
+When strict validation is disabled, response payloads that fail Pydantic validation
+are returned as opaque data that still supports field access, such as
+`response.data.id` or `response.data["id"]`. If `debug=True`, the SDK emits a
+warning with details about the validation error; otherwise, it continues quietly.
 
 ### Authentication
 

{devopness-2.4.1 → devopness-2.5.0}/README.md

@@ -81,6 +81,31 @@ Configuration options:
 | `base_url`           | `https://api.devopness.com` | Base URL for all API requests                       |
 | `timeout`            | `30`                        | Timeout for HTTP requests (in seconds)              |
 | `default_encoding`   | `utf-8`                     | Encoding for response content                       |
+| `debug`              | `False`                     | Prints HTTP debug output and validation warnings    |
+| `strict_validation_mode` | `True`                  | Raises Pydantic validation errors for API responses |
+
+
+#### Response validation mode
+
+The SDK validates API responses against generated Pydantic models by default. This
+strict behavior helps surface mismatches between the API response and the documented
+contract. Consumers that must keep running when a response does not match the model
+can opt out by setting `strict_validation_mode=False`:
+
+```python
+from devopness import DevopnessClient, DevopnessClientConfig
+
+config = DevopnessClientConfig(
+    strict_validation_mode=False,
+    debug=True,
+)
+devopness = DevopnessClient(config)
+```
+
+When strict validation is disabled, response payloads that fail Pydantic validation
+are returned as opaque data that still supports field access, such as
+`response.data.id` or `response.data["id"]`. If `debug=True`, the SDK emits a
+warning with details about the validation error; otherwise, it continues quietly.
 
 ### Authentication
 

{devopness-2.4.1 → devopness-2.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "devopness"
-version = "2.4.1"
+version = "2.5.0"
 description = "Devopness API Python SDK - Painless essential DevOps to everyone"
 license = "MIT"
 readme = "README.md"
@@ -68,8 +68,8 @@ exclude = ["src/devopness/generated/.openapi-generator-ignore"]
 
 [tool.poetry.group.dev.dependencies]
 openapi-generator-cli = { version = "7.22.0", markers = "python_version < '4.0'" }
-ruff = "^0.15.13"
-mypy = "2.1.0"
+ruff = "^0.15.16"
+mypy = "^2.1.0"
 
 [tool.ruff]
 line-length = 88

{devopness-2.4.1 → devopness-2.5.0}/src/devopness/client_config.py

@@ -41,6 +41,8 @@ class DevopnessClientConfig(DevopnessBaseModel):
                                    no longer necessary with token-based auth.
         base_url (str): Base URL for API requests.
         debug (bool): Controls whether debug information is printed to the console.
+        strict_validation_mode (bool): Controls whether response validation errors
+                                       raise.
         default_encoding (str): Default encoding for response content.
         headers (dict[str, str]): Default headers for API requests.
         timeout (int): Request timeout in seconds.
@@ -54,6 +56,7 @@ class DevopnessClientConfig(DevopnessBaseModel):
     """
     base_url: str = "https://api.devopness.com"
     debug: bool = False
+    strict_validation_mode: bool = True
     default_encoding: str = "utf-8"
     headers: dict[str, str] = {  # noqa: RUF012
         "Accept": "application/json",
@@ -105,6 +108,7 @@ class DevopnessClientConfigDict(TypedDict, total=False):
     auto_refresh_token: bool
     base_url: str
     debug: bool
+    strict_validation_mode: bool
     default_encoding: str
     headers: dict[str, str]
     timeout: int

{devopness-2.4.1 → devopness-2.5.0}/src/devopness/core/api_error.py

@@ -50,7 +50,7 @@ class DevopnessApiError(DevopnessSdkError):
         self.errors = None
         self.message = str(err)
 
-        try:
+        try:  # noqa: PLW0717
             res_data = e_res.json()
 
             if isinstance(res_data, dict):

{devopness-2.4.1 → devopness-2.5.0}/src/devopness/core/response.py

@@ -3,6 +3,7 @@ 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
@@ -17,6 +18,19 @@ __all__ = ["DevopnessResponse"]
 T = TypeVar("T")
 
 
+class _OpaqueResponseData(dict[str, Any]):
+    """Opaque wrapper for response payloads that fail model validation."""
+
+    def __getattr__(self, key: str) -> Any:  # noqa: ANN401
+        try:
+            return self[key]
+        except KeyError as e:
+            raise AttributeError(key) from e
+
+    def to_dict(self) -> dict[str, Any]:
+        return dict(self)
+
+
 class DevopnessResponse(Generic[T]):
     """
     Represents a typed API response from the Devopness API.
@@ -50,6 +64,7 @@ class DevopnessResponse(Generic[T]):
                                                       deserialize the response
                                                       body into.
         """
+        self._is_async_response = False
         self.status = response.status_code
         self.data = cast(T, self._parse_data(response, model_cls))
         self.page_count = self._extract_last_page_number(response)
@@ -73,6 +88,7 @@ class DevopnessResponse(Generic[T]):
         """
         result = cls.__new__(cls)
 
+        result._is_async_response = True
         result.status = response.status_code
         result.data = cast(T, await result._async_parse_data(response, model_cls))
         result.page_count = result._extract_last_page_number(response)
@@ -146,7 +162,7 @@ class DevopnessResponse(Generic[T]):
             model_cls: The target model class to convert the data into
 
         Returns:
-            Parsed data in the requested format or raw string on failure
+            Parsed data in the requested format or opaque data in non-strict mode
         """
         raw_data: bytes = response.read()
 
@@ -173,7 +189,7 @@ class DevopnessResponse(Generic[T]):
             model_cls: The target model class to convert the data into
 
         Returns:
-            Parsed data in the requested format or raw string on failure
+            Parsed data in the requested format or opaque data in non-strict mode
         """
         raw_data: bytes = await response.aread()
 
@@ -199,7 +215,7 @@ class DevopnessResponse(Generic[T]):
         if raw_data == b"" or model_cls is None:
             return None
 
-        try:
+        try:  # noqa: PLW0717
             # Handle primitive types
             if model_cls is str:
                 return raw_data.decode("utf-8")
@@ -229,8 +245,23 @@ class DevopnessResponse(Generic[T]):
                 dict_data: dict[str, Any] = json.loads(raw_data.decode("utf-8"))
                 return model_cls.from_dict(dict_data)
 
-        except (json.JSONDecodeError, ValidationError) as e:
-            model_name = model_cls.__name__ if model_cls else "None"
+        except ValidationError as e:
+            if self._is_strict_validation_mode():
+                raise
+
+            if self._is_debug_mode():
+                model_name = self._model_name(model_cls)
+                msg = (
+                    f"Failed to deserialize response body into {model_name}. "
+                    "Returning opaque response data instead.\n\n"
+                    f"Error: {self._safe_validation_error_details(e)}"
+                )
+                warn(msg, stacklevel=3)
+
+            return self._opaque_data_from_raw_data(raw_data)
+
+        except json.JSONDecodeError as e:
+            model_name = self._model_name(model_cls)
             msg = (
                 f"Failed to deserialize response body into {model_name}. "
                 "Returning raw response data instead.\n\n"
@@ -240,3 +271,56 @@ class DevopnessResponse(Generic[T]):
 
         # Fallback to raw string data
         return raw_data.decode("utf-8")
+
+    @staticmethod
+    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)
+
+        return getattr(service, "_config", None)
+
+    def _is_strict_validation_mode(self) -> bool:
+        return getattr(self._config(), "strict_validation_mode", True)
+
+    def _is_debug_mode(self) -> bool:
+        return getattr(self._config(), "debug", False)
+
+    @staticmethod
+    def _safe_validation_error_details(error: ValidationError) -> str:
+        error_details: list[str] = []
+        for item in error.errors(include_url=False, include_input=False):
+            loc = item.get("loc", ())
+            loc_text = ".".join(str(part) for part in loc) if loc else "<root>"
+            error_type = item.get("type", "unknown")
+            error_details.append(f"{loc_text} ({error_type})")
+
+        return "; ".join(error_details)
+
+    def _opaque_data_from_raw_data(
+        self, raw_data: bytes
+    ) -> str | int | float | bool | dict[str, Any] | list[Any] | None:
+        try:
+            return self._wrap_opaque_data(json.loads(raw_data.decode("utf-8")))
+        except json.JSONDecodeError:
+            return raw_data.decode("utf-8")
+
+    def _wrap_opaque_data(
+        self, data: object
+    ) -> str | int | float | bool | dict[str, Any] | list[Any] | None:
+        if isinstance(data, dict):
+            return _OpaqueResponseData(
+                {key: self._wrap_opaque_data(value) for key, value in data.items()}
+            )
+
+        if isinstance(data, list):
+            return [self._wrap_opaque_data(item) for item in data]
+
+        return cast(str | int | float | bool | None, data)