fix: 'dict' object has no attribute 'name'

Author: Rana718

astraapi/_compat/v2.py

@@ -138,6 +138,20 @@ def validate(
             return None, _regenerate_error_with_loc(
                 errors=exc.errors(include_url=False), loc_prefix=loc
             )
+        except (TypeError, AttributeError) as exc:
+            # Pydantic v2 validate_python with from_attributes=True can raise
+            # TypeError/AttributeError when re-validating model instances that
+            # contain nested dicts (e.g. model_construct bypass) or when
+            # computed fields access missing attributes.
+            return None, _regenerate_error_with_loc(
+                errors=[{
+                    "type": "response_validation_error",
+                    "loc": loc,
+                    "msg": str(exc),
+                    "input": value,
+                }],
+                loc_prefix=loc,
+            )
 
     def serialize(
         self,

astraapi/applications.py

@@ -1241,15 +1241,33 @@ async def _response_model_shim(**kwargs: Any) -> Any:
                 except Exception:
                     pass
                 raise exc
-            return response_field.serialize(
-                value,
-                include=response_model_include,
-                exclude=response_model_exclude,
-                by_alias=response_model_by_alias,
-                exclude_unset=response_model_exclude_unset,
-                exclude_defaults=response_model_exclude_defaults,
-                exclude_none=response_model_exclude_none,
-            )
+            try:
+                return response_field.serialize(
+                    value,
+                    include=response_model_include,
+                    exclude=response_model_exclude,
+                    by_alias=response_model_by_alias,
+                    exclude_unset=response_model_exclude_unset,
+                    exclude_defaults=response_model_exclude_defaults,
+                    exclude_none=response_model_exclude_none,
+                )
+            except (TypeError, AttributeError) as _ser_exc:
+                from astraapi.exceptions import ResponseValidationError
+                _rve = ResponseValidationError(
+                    errors=[{
+                        "type": "response_serialization_error",
+                        "loc": ("response",),
+                        "msg": str(_ser_exc),
+                        "input": raw,
+                    }],
+                    body=raw,
+                )
+                try:
+                    from astraapi._cpp_server import _set_last_server_exception
+                    _set_last_server_exception(_rve)
+                except Exception:
+                    pass
+                raise _rve
 
         _response_model_shim.__name__ = getattr(original_endpoint, "__name__", "_response_model_shim")
         return _response_model_shim
@@ -1836,15 +1854,39 @@ async def _mw_call_next(_req, _r=_mw_resp):
                         except Exception:
                             pass
                         raise _rve
-                    result = _response_field.serialize(
-                        _val,
-                        include=_rm_include,
-                        exclude=_rm_exclude,
-                        by_alias=_rm_by_alias,
-                        exclude_unset=_rm_exclude_unset,
-                        exclude_defaults=_rm_exclude_defaults,
-                        exclude_none=_rm_exclude_none,
-                    )
+                    try:
+                        result = _response_field.serialize(
+                            _val,
+                            include=_rm_include,
+                            exclude=_rm_exclude,
+                            by_alias=_rm_by_alias,
+                            exclude_unset=_rm_exclude_unset,
+                            exclude_defaults=_rm_exclude_defaults,
+                            exclude_none=_rm_exclude_none,
+                        )
+                    except (TypeError, AttributeError) as _ser_exc:
+                        from astraapi.exceptions import ResponseValidationError as _RVE
+                        from astraapi.routing import _extract_endpoint_context
+                        _rve_ctx = _extract_endpoint_context(original_endpoint)
+                        _dep = getattr(route, 'dependant', None)
+                        if _dep and getattr(_dep, 'path', None):
+                            _rve_ctx['path'] = f"GET {_dep.path}"
+                        _rve = _RVE(
+                            errors=[{
+                                "type": "response_serialization_error",
+                                "loc": ("response",),
+                                "msg": str(_ser_exc),
+                                "input": result,
+                            }],
+                            body=result,
+                            endpoint_ctx=_rve_ctx,
+                        )
+                        try:
+                            from astraapi._cpp_server import _set_last_server_exception as _slse
+                            _slse(_rve)
+                        except Exception:
+                            pass
+                        raise _rve
                 # Not a Response — wrap using the route's response_class
                 if _is_redirect:
                     # Pass only the URL; let RedirectResponse use its own default status_code

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "astraapi"
-version = "0.2.1"
+version = "0.2.11"
 description = "AstraAPI framework, high performance, easy to learn, fast to code, ready for production"
 readme = "README.md"
 license = {text = "MIT"}

release_notes.md

@@ -1,92 +1,22 @@
-# AstraAPI 0.2.1 Release Notes
+# AstraAPI 0.2.11 Release Notes
 
-**PyPI:** https://pypi.org/project/astraapi/0.2.1  
+**PyPI:** https://pypi.org/project/astraapi/0.2.11  
 **Python:** 3.14+ | **C++:** 20
 
 ---
 
 ## Overview
 
-AstraAPI 0.2.1 is a stability and compatibility release for our FastAPI-compatible web framework powered by a compiled C++20 core. This release fixes editor IntelliSense, resolves Windows build failures, hardens CI/CD pipelines, and raises the minimum Python version to **3.14**.
-
-```python
-from astraapi import AstraAPI
-
-app = AstraAPI()
-
-@app.get("/")
-def hello():
-    return {"message": "Hello World"}
-
-if __name__ == "__main__":
-    app.run(port=8000, workers=4)
-```
-
----
-
-## Breaking Changes
-
-### Minimum Python Version Raised to 3.14
-- **Dropped support for Python 3.12 and 3.13.**
-- The codebase leverages `annotationlib` (PEP 649 deferred annotations) and other 3.14-specific runtime features that are not back-portable.
-- Wheels are now built **exclusively** for `cp314` (Linux x86_64/aarch64, macOS arm64, Windows x64).
-- Updated all docs, Docker examples, and CI matrices to reflect `python:3.14-slim`.
+Patch release that fixes a runtime compatibility issue where endpoints returning `list[PydanticModel]` could crash with `'dict' object has no attribute 'name'` during response validation/serialization.
 
 ---
 
-## What's New
-
-### Editor IntelliSense & Static Analysis
-- **Added `astraapi/py.typed`** — PEP 561 marker so Pylance, Pyright, and mypy recognize the package as fully typed.
-- **Added `astraapi/__init__.pyi`** — Stub file with explicit re-exports of all 20 public symbols (`AstraAPI`, `Depends`, `HTTPException`, `Request`, `Response`, `APIRouter`, `WebSocket`, etc.).
-- **Root cause:** `astraapi/__init__.py` used `__getattr__` lazy loading for fast cold-start (~1 s vs ~4.7 s). While great for runtime, it completely broke static resolution. The `.pyi` stub restores autocomplete, "Go to Definition", and type checking without changing runtime behavior.
-
-### Windows Build Fixes
-- **`cpp_core/src/app.cpp`** — Added `#define NOMINMAX` before `Python.h` to prevent Windows `min`/`max` macros from clashing with `std::min`/`std::max` (MSVC `C2589` / `C2059`).
-- **`cpp_core/src/streaming_multipart.cpp`** — Replaced POSIX-only `mkstemp` / `write` / `close` with cross-platform `std::fopen` / `std::fwrite` / `std::fclose` + `std::filesystem::temp_directory_path()`.
-- **`cpp_core/include/streaming_multipart.hpp`** — Renamed enum value `ERROR` → `ERR` in both `MultipartState` and `FeedResult`. Windows defines `ERROR` as a macro (`0`), causing `FeedResult::ERROR` to expand to `FeedResult::0` (syntax error).
-- **`scripts/build_core.sh`** — Now passes `-DPython3_EXECUTABLE="$(python -c 'import sys; print(sys.executable)')"` to CMake to guarantee the C++ extension is built against the same Python that runs it.
-
-### CI/CD Hardening
-- **`.github/workflows/tests.yml`** — Switched from `pip` to `uv` for faster installs. Installs `".[dev,standard]"` to ensure `httpx`, `jinja2`, `python-multipart`, and other standard extras are present during testing. Uses Python 3.14 explicitly (matching local dev and `uv`'s managed Python).
-- **`.github/workflows/publish.yml`** — `CIBW_BUILD` narrowed to `cp314-*` only. Fixed CMake Python version mismatch that caused segfaults when the runtime Python differed from the build-time Python.
+## Bug Fixes
 
-### Test Stability
-- **`astraapi/_testclient.py`** — TestClient shared server registry now uses `_app_instance_id` (monotonic counter) instead of `id(app)`. Python's allocator recycles object addresses, causing servers to be incorrectly reused across tests.
-- **`astraapi/applications.py`** — Custom route classes now pass `dep_inject_mask=0x07` so the C++ core injects `__raw_headers__`, `__method__`, `__path__` directly into kwargs, eliminating a ContextVar fallback race in `_asgi_shim`.
+### Response Model Validation/Serialization Robustness
 
-### Documentation
-- **VitePress `base` path** — Changed from `/Astraapi/` to `/` to support custom root domains (e.g., `https://astraapi.lumoslab.tech/`). Previously CSS/assets 404'd when the site was served at a domain root instead of a GitHub Pages subdirectory.
-- **Dev dependencies** — Added missing test-only packages to `[project.optional-dependencies] dev`: `starlette`, `httpx`, `jinja2`, `python-multipart`, `email-validator`, `pydantic-settings`, `pydantic-extra-types`, `websockets`, `uvicorn`.
-
----
-
-## Architecture
-
-| Layer | Technology |
-|-------|-----------|
-| HTTP parser | llhttp (Node.js parser, compiled into C++ extension) |
-| JSON encoder | yyjson (zero-allocation, SIMD-accelerated) |
-| JSON serializer | Custom C++20 string builder with SSE2/NEON small-string optimization |
-| Compression | libdeflate (optional, ~3× faster than zlib) |
-| WebSocket framing | Custom C++ frame parser + ring buffer |
-| Response serialization | C++ `HTTPResponse` → Python `bytes` via memoryview (zero-copy when possible) |
-| Dependency injection | C++ topological sort (`compute_dependency_order`) at route registration time |
-| Parameter extraction | C++ scalar coercion + batch validation (avoids per-request Python loops) |
-
----
-
-## Performance
-
-| Metric | Value | Notes |
-|--------|-------|-------|
-| Cold import | ~1.0 s | `__getattr__` lazy loading defers pydantic/openapi until first use |
-| Hello World RPS | 450K+ | Single process, keep-alive, C++ core serving directly |
-| Latency p99 | 0.8 ms | `wrk -t4 -c400 -d30s` on AMD Ryzen 9 |
-| JSON serialization | ~2× faster | Custom C++ string builder vs `json.dumps` |
-| Multi-process | Linear scaling | `app.run(workers=N)` uses `SO_REUSEPORT` + pre-fork |
-
-*Benchmarks: Python 3.14, C++20, AMD Ryzen 9, 16 workers, wrk2*
+- **`astraapi/_compat/v2.py`** — `ModelField.validate()` now catches `TypeError` and `AttributeError` in addition to `ValidationError`. Pydantic v2's `validate_python(..., from_attributes=True)` can raise these exceptions when re-validating model instances that contain nested dicts (e.g., `model_construct` bypass) or when computed fields access missing attributes.
+- **`astraapi/applications.py`** — Both `_make_response_model_shim` and `_make_response_class_shim` now wrap `response_field.serialize()` in try-except to catch `TypeError` and `AttributeError` and convert them to `ResponseValidationError` instead of letting raw exceptions propagate and crash the request.
 
 ---
 
@@ -96,6 +26,4 @@ if __name__ == "__main__":
 pip install astraapi
 ```
 
-Requires **Python 3.14+** and a C++20-capable compiler (GCC 10+, Clang 12+, MSVC 2019+). Pre-built wheels are provided for Linux x86_64/aarch64, macOS arm64, and Windows x64. The C++ extension builds automatically from source if a wheel is not available for your platform.
-
----
+Requires **Python 3.14+** and a C++20-capable compiler (GCC 10+, Clang 12+, MSVC 2019+). Pre-built wheels are provided for Linux x86_64/aarch64, macOS arm64, and Windows x64.

tests/test_response_model_serialization_errors.py

@@ -0,0 +1,77 @@
+"""Regression tests for response model serialization edge cases.
+
+Covers: AttributeError/TypeError during validate_python with from_attributes=True
+when re-validating model instances that contain nested dicts (e.g. model_construct
+bypass) or when computed fields access missing attributes.
+"""
+import pytest
+from pydantic import BaseModel, computed_field
+from typing import Optional
+
+from astraapi import AstraAPI
+from astraapi.testclient import TestClient
+from astraapi.exceptions import ResponseValidationError
+
+
+class Inner(BaseModel):
+    name: str
+
+
+class Outer(BaseModel):
+    inner: Optional[Inner] = None
+
+    @computed_field
+    @property
+    def display_name(self) -> str:
+        # This will fail if inner is a dict instead of Inner
+        return self.inner.name
+
+
+class PlainOuter(BaseModel):
+    inner: Optional[Inner] = None
+
+
+def test_valid_model_instance_serializes_normally():
+    """Normal model instances should still serialize correctly."""
+    app = AstraAPI()
+
+    @app.get("/items", response_model=list[PlainOuter])
+    def get_items():
+        return [PlainOuter(inner=Inner(name="test"))]
+
+    client = TestClient(app)
+    response = client.get("/items")
+    assert response.status_code == 200
+    assert response.json() == [{"inner": {"name": "test"}}]
+
+
+def test_computed_field_attribute_error_serialization():
+    """A computed field that accesses an attribute on a dict should raise
+    ResponseValidationError, not raw AttributeError."""
+    app = AstraAPI()
+
+    @app.get("/items", response_model=list[Outer])
+    def get_items():
+        return [Outer.model_construct(inner={"name": "test"})]
+
+    client = TestClient(app)
+    with pytest.raises(ResponseValidationError):
+        client.get("/items")
+
+
+def test_computed_field_with_custom_exception_handler():
+    """Even with a catch-all Exception handler, ResponseValidationError
+    should be raised (TestClient re-raises it as a programming error)."""
+    app = AstraAPI()
+
+    @app.exception_handler(Exception)
+    async def generic_handler(request, exc):
+        return {"error": str(exc)}
+
+    @app.get("/items", response_model=list[Outer])
+    def get_items():
+        return [Outer.model_construct(inner={"name": "test"})]
+
+    client = TestClient(app)
+    with pytest.raises(ResponseValidationError):
+        client.get("/items")