django-nested-values 0.6.14__tar.gz → 0.7.0__tar.gz

{django_nested_values-0.6.14 → django_nested_values-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-nested-values
-Version: 0.6.14
+Version: 0.7.0
 Summary: Add .values_nested() to Django querysets for nested prefetch dictionaries
 Project-URL: Homepage, https://github.com/oliverhaas/django-nested-values
 Project-URL: Documentation, https://oliverhaas.github.io/django-nested-values/

{django_nested_values-0.6.14 → django_nested_values-0.7.0}/django_nested_values/__init__.py

@@ -4,8 +4,7 @@ from django_nested_values.queryset import (
     AttrDict,
     NestedValuesQuerySet,
     NestedValuesQuerySetMixin,
-    RelatedList,
 )
 
-__all__ = ["AttrDict", "NestedValuesQuerySet", "NestedValuesQuerySetMixin", "RelatedList"]
-__version__ = "0.5.2"
+__all__ = ["AttrDict", "NestedValuesQuerySet", "NestedValuesQuerySetMixin"]
+__version__ = "0.7.0"

{django_nested_values-0.6.14 → django_nested_values-0.7.0}/django_nested_values/queryset.py

@@ -15,6 +15,40 @@ from django.db.models.query import BaseIterable
 # TypeVar for the model type, used for generic typing with django-stubs
 _ModelT_co = TypeVar("_ModelT_co", bound=Model, covariant=True)
 
+# Type alias for dict-like container classes
+_ContainerType = type[dict[str, Any]]
+
+
+class AttrDict(dict[str, Any]):
+    """Dict subclass with attribute access - minimal overhead.
+
+    Inherits from dict so isinstance(x, dict) is True and all dict
+    operations work unchanged. Just adds __getattr__ for dot access.
+    """
+
+    __slots__ = ()
+
+    def __getattr__(self, name: str) -> Any:
+        """Get item as attribute."""
+        try:
+            return self[name]
+        except KeyError:
+            msg = f"'{type(self).__name__}' object has no attribute '{name}'"
+            raise AttributeError(msg) from None
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        """Set item as attribute."""
+        self[name] = value
+
+    def __delattr__(self, name: str) -> None:
+        """Delete item as attribute."""
+        try:
+            del self[name]
+        except KeyError:
+            msg = f"'{type(self).__name__}' object has no attribute '{name}'"
+            raise AttributeError(msg) from None
+
+
 if TYPE_CHECKING:
     from collections.abc import Iterator
 
@@ -27,71 +61,57 @@ else:
     _MixinBase = Generic
 
 
-def _build_dict_from_klass_info(
+def _build_from_klass_info(
     row: tuple[Any, ...],
     klass_info: dict[str, Any],
     select: list[tuple[Any, ...]],
+    container: _ContainerType = dict,
 ) -> dict[str, Any]:
-    """Build a dict for a model from a row using klass_info metadata.
+    """Build a dict (or dict subclass like AttrDict) directly from a row.
 
     This uses Django's internal compiler metadata to know exactly which
     columns belong to which model, avoiding manual field path parsing.
 
     Args:
         row: A tuple of values from the database row
-        klass_info: The klass_info dict from compiler, containing:
-            - 'model': the model class
-            - 'select_fields': list of column indices for this model
-            - 'related_klass_infos': list of klass_info for select_related models
-        select: The compiler.select list, mapping indices to column expressions
+        klass_info: The klass_info dict from compiler
+        select: The compiler.select list
+        container: The dict-like class to use (dict or AttrDict)
 
     Returns:
-        A dict with field names as keys and values from the row
+        A container instance with field names as keys
 
     """
-    result: dict[str, Any] = {}
+    # Build directly into the container - no intermediate dict
+    result = container()
 
     for idx in klass_info["select_fields"]:
         col_expr = select[idx][0]
-        field_name = col_expr.target.attname  # attname gives 'publisher_id' for FKs
-        result[field_name] = row[idx]
+        result[col_expr.target.attname] = row[idx]
 
     for related_ki in klass_info.get("related_klass_infos", []):
-        relation_name = related_ki["field"].name
-
-        # Check if related object is NULL (first select_field is typically the PK)
         pk_idx = related_ki["select_fields"][0]
         if row[pk_idx] is None:
             continue
-
-        nested_dict = _build_dict_from_klass_info(row, related_ki, select)
-        result[relation_name] = nested_dict
+        result[related_ki["field"].name] = _build_from_klass_info(row, related_ki, select, container)
 
     return result
 
 
-def _execute_queryset_as_dicts(
+def _execute_queryset(
     queryset: QuerySet[Any, Any],
     db: str,
+    container: _ContainerType = dict,
 ) -> list[dict[str, Any]]:
-    """Execute a queryset using the compiler and return results as nested dicts.
-
-    This uses Django's internal compiler to execute the query and builds
-    nested dictionaries directly from the raw row tuples - NO model instantiation.
-
-    The pipeline is: raw SQL rows → dicts (via klass_info metadata)
-
-    This handles:
-    - select_related: Automatically builds nested dicts for related objects
-    - only()/defer(): Compiler respects deferred field loading
-    - Custom querysets: Works with any queryset (base, filtered, etc.)
+    """Execute a queryset and return results as nested dicts (or AttrDict).
 
     Args:
-        queryset: The queryset to execute (may have select_related, only, etc.)
+        queryset: The queryset to execute
         db: Database alias to use
+        container: The dict-like class to use (dict or AttrDict)
 
     Returns:
-        List of nested dictionaries, one per row
+        List of nested containers, one per row
 
     """
     compiler = queryset.query.get_compiler(using=db)
@@ -106,20 +126,25 @@ def _execute_queryset_as_dicts(
     if klass_info is None:
         return []
 
-    return [_build_dict_from_klass_info(row, klass_info, select) for row in compiler.results_iter(results)]
+    return [_build_from_klass_info(row, klass_info, select, container) for row in compiler.results_iter(results)]
 
 
-def _execute_prefetch_as_dicts(
+def _execute_prefetch(
     queryset: QuerySet[Any, Any],
     db: str,
+    container: _ContainerType = dict,
 ) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
-    """Execute a prefetch queryset and return (dicts, extra_values).
+    """Execute a prefetch queryset and return (containers, extra_values).
+
+    This extracts the extra columns Django adds for prefetch grouping.
 
-    This is similar to _execute_queryset_as_dicts but also extracts the extra
-    columns that Django adds for prefetch grouping (like _prefetch_related_val_*).
+    Args:
+        queryset: The queryset to execute
+        db: Database alias to use
+        container: The dict-like class to use (dict or AttrDict)
 
     Returns:
-        Tuple of (list of model dicts, list of extra column dicts for grouping)
+        Tuple of (list of model containers, list of extra column dicts for grouping)
 
     """
     compiler = queryset.query.get_compiler(using=db)
@@ -135,152 +160,22 @@ def _execute_prefetch_as_dicts(
         return [], []
 
     # Find extra column indices (columns with _prefetch_related_val_* alias)
-    # Extra columns from .extra() have format: (RawSQL, (sql, params), alias)
     extra_indices = [
         (i, s[2])
         for i, s in enumerate(select)
         if len(s) >= 3 and s[2] and s[2].startswith("_prefetch_related_val_")  # noqa: PLR2004
     ]
 
-    dicts = []
+    containers = []
     extra_values = []
 
     for row in compiler.results_iter(results):
-        row_dict = _build_dict_from_klass_info(row, klass_info, select)
+        row_container = _build_from_klass_info(row, klass_info, select, container)
         extra_vals = {alias: row[idx] for idx, alias in extra_indices}
-
-        dicts.append(row_dict)
+        containers.append(row_container)
         extra_values.append(extra_vals)
 
-    return dicts, extra_values
-
-
-class RelatedList(list[Any]):
-    """List wrapper that provides .all() method to mimic Django's related manager.
-
-    This allows code like `for book in author.books.all()` to work with nested values,
-    making the results more drop-in compatible with Django ORM patterns.
-    """
-
-    __slots__ = ()
-
-    def all(self) -> Self:
-        """Return self to mimic Django's related manager .all() method."""
-        return self
-
-
-class AttrDict:
-    """Dict wrapper that provides attribute access to mimic Django model instances.
-
-    Supports both attribute access (book.title) and dict access (book["title"]).
-    Nested dicts are wrapped as AttrDict, lists are wrapped as RelatedList.
-
-    Example:
-        >>> obj = AttrDict({"title": "Django", "publisher": {"name": "Pub"}})
-        >>> obj.title
-        'Django'
-        >>> obj["title"]
-        'Django'
-        >>> obj.publisher.name
-        'Pub'
-
-    """
-
-    __slots__ = ("_data",)
-
-    def __init__(self, data: dict[str, Any]) -> None:
-        """Initialize with a dict. Nested values are wrapped eagerly."""
-        # Wrap nested structures eagerly
-        wrapped: dict[str, Any] = {}
-        for key, value in data.items():
-            wrapped[key] = self._wrap_value(value)
-        object.__setattr__(self, "_data", wrapped)
-
-    @staticmethod
-    def _wrap_value(value: Any) -> Any:
-        """Wrap a value: dicts become AttrDict, lists become RelatedList."""
-        if isinstance(value, dict):
-            return AttrDict(value)
-        if isinstance(value, list):
-            return RelatedList(AttrDict._wrap_value(item) for item in value)
-        return value
-
-    def __getattr__(self, name: str) -> Any:
-        """Get attribute from underlying dict."""
-        try:
-            return self._data[name]
-        except KeyError:
-            msg = f"'{type(self).__name__}' object has no attribute '{name}'"
-            raise AttributeError(msg) from None
-
-    def __setattr__(self, name: str, value: Any) -> None:
-        """Set attribute in underlying dict."""
-        if name == "_data":
-            object.__setattr__(self, name, value)
-        else:
-            self._data[name] = self._wrap_value(value)
-
-    def __getitem__(self, key: str) -> Any:
-        """Get item from underlying dict."""
-        return self._data[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        """Set item in underlying dict."""
-        self._data[key] = self._wrap_value(value)
-
-    def __contains__(self, key: object) -> bool:
-        """Check if key exists in underlying dict."""
-        return key in self._data
-
-    def __iter__(self) -> Iterator[str]:
-        """Iterate over keys in underlying dict."""
-        return iter(self._data)
-
-    def __len__(self) -> int:
-        """Return number of keys in underlying dict."""
-        return len(self._data)
-
-    def __repr__(self) -> str:
-        """Return repr of underlying dict."""
-        return f"AttrDict({self._data!r})"
-
-    def __eq__(self, other: object) -> bool:
-        """Compare with another AttrDict or dict."""
-        if isinstance(other, AttrDict):
-            return bool(self._data == other._data)
-        if isinstance(other, dict):
-            return bool(self._data == other)
-        return NotImplemented
-
-    __hash__: None = None  # type: ignore[assignment]  # Mutable container, so explicitly unhashable
-
-    def keys(self) -> Any:
-        """Return keys of underlying dict."""
-        return self._data.keys()
-
-    def values(self) -> Any:
-        """Return values of underlying dict."""
-        return self._data.values()
-
-    def items(self) -> Any:
-        """Return items of underlying dict."""
-        return self._data.items()
-
-    def get(self, key: str, default: Any = None) -> Any:
-        """Get item with default from underlying dict."""
-        return self._data.get(key, default)
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert back to a plain dict (recursively unwraps nested objects)."""
-        result: dict[str, Any] = {}
-        for key, value in self._data.items():
-            if isinstance(value, AttrDict):
-                result[key] = value.to_dict()
-            elif isinstance(value, RelatedList):
-                result[key] = [item.to_dict() if isinstance(item, AttrDict) else item for item in value]
-            else:
-                result[key] = value
-        return result
+    return containers, extra_values
 
 
 class NestedValuesIterable(BaseIterable):  # type: ignore[type-arg]
@@ -294,12 +189,10 @@ class NestedValuesIterable(BaseIterable):  # type: ignore[type-arg]
         # The queryset is expected to be a NestedValuesQuerySetMixin
         queryset: NestedValuesQuerySetMixin[Any]
 
-    def __iter__(self) -> Iterator[dict[str, Any] | AttrDict]:
-        """Iterate over the queryset, yielding nested dictionaries or AttrDicts."""
+    def __iter__(self) -> Iterator[dict[str, Any]]:
+        """Iterate over the queryset, yielding nested dictionaries (or AttrDict)."""
         queryset = self.queryset
         db = queryset.db
-        # Use _nested_prefetch_lookups which is set by values_nested() - we clear
-        # _prefetch_related_lookups to prevent Django from double-prefetching
         prefetch_lookups = getattr(queryset, "_nested_prefetch_lookups", ())
 
         main_qs = queryset._build_main_queryset()
@@ -318,34 +211,40 @@ class NestedValuesIterable(BaseIterable):  # type: ignore[type-arg]
         if klass_info is None:
             return
 
-        main_results = [_build_dict_from_klass_info(row, klass_info, select) for row in compiler.results_iter(results)]
+        # Choose container based on as_attr_dicts flag
+        as_attr_dicts = getattr(queryset, "_as_attr_dicts", False)
+        container: _ContainerType = AttrDict if as_attr_dicts else dict  # type: ignore[assignment]
+        pk_name = queryset.model._meta.pk.name
+
+        # Build main results - unified path for both dict and AttrDict
+        main_results = [
+            _build_from_klass_info(row, klass_info, select, container) for row in compiler.results_iter(results)
+        ]
         if not main_results:
             return
 
-        # Check if we should wrap results as AttrDict
-        as_attr_dicts = getattr(queryset, "_as_attr_dicts", False)
-
         if not prefetch_lookups:
-            for row in main_results:
-                yield AttrDict(row) if as_attr_dicts else row
+            yield from main_results
             return
 
-        pk_name = queryset.model._meta.pk.name
+        # Fetch prefetched data and attach to main results
         pk_values = [r[pk_name] for r in main_results]
-        prefetched_data = queryset._fetch_all_prefetched(prefetch_lookups, pk_values, main_results)
+        prefetched_data = queryset._fetch_all_prefetched(
+            prefetch_lookups,
+            pk_values,
+            main_results,
+            container=container,
+        )
 
         for row in main_results:
             pk = row[pk_name]
             for attr_name, data_by_pk in prefetched_data.items():
                 prefetch_value = data_by_pk.get(pk, [])
                 self._set_nested_value(row, attr_name, prefetch_value)
-            yield AttrDict(row) if as_attr_dicts else row
+            yield row
 
     def _set_nested_value(self, row: dict[str, Any], attr_path: str, value: Any) -> None:
-        """Set a value in a nested dict using a path like 'publisher__books'.
-
-        Navigates to the correct nested location and sets or merges the value.
-        """
+        """Set a value in a nested dict using a path like 'publisher__books'."""
         parts = attr_path.split("__")
         target = row
 
@@ -361,17 +260,11 @@ class NestedValuesIterable(BaseIterable):  # type: ignore[type-arg]
             existing = target[final_key]
             if isinstance(existing, dict) and isinstance(value, dict):
                 self._merge_dicts(existing, value)
-            # Otherwise keep existing (select_related takes precedence)
         else:
             target[final_key] = value
 
     def _merge_dicts(self, target: dict[str, Any], source: dict[str, Any]) -> None:
-        """Recursively merge source dict into target dict.
-
-        New keys from source are added. For existing keys where both values
-        are dicts, recursively merge. Otherwise, target value takes precedence
-        (select_related data wins over prefetch data for same field).
-        """
+        """Recursively merge source dict into target dict."""
         for key, value in source.items():
             if key not in target:
                 target[key] = value
@@ -379,12 +272,7 @@ class NestedValuesIterable(BaseIterable):  # type: ignore[type-arg]
                 self._merge_dicts(target[key], value)
 
     def _ensure_fk_fields_not_deferred(self, qs: QuerySet[Any, Any]) -> None:
-        """Ensure FK fields for select_related are not deferred.
-
-        When using .only() without the FK field and then select_related(),
-        Django would raise an error. This method clears deferral for FK fields
-        that are traversed via select_related.
-        """
+        """Ensure FK fields for select_related are not deferred."""
         select_related = qs.query.select_related
         if not select_related:
             return
@@ -393,13 +281,9 @@ class NestedValuesIterable(BaseIterable):  # type: ignore[type-arg]
         if not deferred_fields:
             return
 
-        # Get FK field names for select_related relations
         if select_related is True:
-            # select_related() with no args - need all FK fields
             fk_fields = {f.attname for f in qs.model._meta.concrete_fields if isinstance(f, ForeignKey)}
         else:
-            # select_related is a dict like {'publisher': {}, 'author': {'publisher': {}}}
-            # We need the FK attnames for top-level relations
             fk_fields = set()
             for relation_name in select_related:
                 try:
@@ -433,19 +317,14 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
             objects = MyQuerySet.as_manager()
 
     Or use the pre-built NestedValuesQuerySet if you don't need a custom QuerySet.
-
-    Type hints: After calling values_nested(), the queryset yields dict[str, Any]
-    when iterated, similar to Django's values() method.
     """
 
-    # Custom attributes that should be preserved when cloning
     _nested_prefetch_lookups: tuple[Any, ...] = ()
     _as_attr_dicts: bool = False
 
     def _clone(self) -> Self:
         """Clone the queryset, preserving our custom attributes."""
         clone: Self = super()._clone()  # type: ignore[misc]
-        # Copy our custom attributes to the clone
         clone._nested_prefetch_lookups = self._nested_prefetch_lookups
         clone._as_attr_dicts = self._as_attr_dicts
         return clone
@@ -474,24 +353,15 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
         Args:
             as_attr_dicts: If True, return AttrDict instances instead of plain dicts.
                 AttrDict supports attribute access (book.title) in addition to
-                dict access (book["title"]), and related lists support .all() to
-                mimic Django's related manager interface.
-
-        Use standard Django methods to control output:
-        - .only() to select which fields to include
-        - .select_related() for ForeignKey relations (single dict/object)
-        - .prefetch_related() for ManyToMany/reverse FK relations (list of dicts/objects)
+                dict access (book["title"]).
 
         Returns:
-            A QuerySet that yields dict[str, Any] or AttrDict when iterated,
-            with nested dictionaries/objects for related objects.
+            A QuerySet that yields dict[str, Any] or AttrDict when iterated.
 
         """
         clone: Self = self._clone()  # type: ignore[assignment]
         clone._iterable_class = NestedValuesIterable
         clone._as_attr_dicts = as_attr_dicts
-        # Store prefetch lookups for our own use, then clear them so Django
-        # doesn't try to prefetch on our dict/AttrDict results
         clone._nested_prefetch_lookups = clone._prefetch_related_lookups  # type: ignore[attr-defined]
         clone._prefetch_related_lookups = ()  # type: ignore[attr-defined]
         return clone  # type: ignore[return-value]
@@ -508,9 +378,11 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
         prefetch_lookups: tuple[Any, ...],
         parent_pks: list[Any],
         main_results: list[dict[str, Any]],
-    ) -> dict[str, dict[Any, list[dict[str, Any]] | dict[str, Any] | None]]:
+        *,
+        container: _ContainerType = dict,
+    ) -> dict[str, dict[Any, Any]]:
         """Fetch all prefetched relations."""
-        result: dict[str, dict[Any, list[dict[str, Any]] | dict[str, Any] | None]] = {}
+        result: dict[str, dict[Any, Any]] = {}
         lookup_map = self._group_prefetch_lookups(prefetch_lookups)
 
         for attr_name, lookup_info in lookup_map.items():
@@ -518,10 +390,11 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
             nested = lookup_info["nested"]
 
             if lookup_info.get("is_generic_fk"):
-                result[attr_name] = self._fetch_generic_fk_values(  # type: ignore[assignment]
+                result[attr_name] = self._fetch_generic_fk_values(
                     lookup,
                     parent_pks,
                     main_results,
+                    container=container,
                 )
             else:
                 result[attr_name] = self._fetch_relation_values(
@@ -529,6 +402,7 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
                     nested,
                     parent_pks,
                     main_results,
+                    container=container,
                 )
 
         return result
@@ -551,7 +425,7 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
 
                 if "__" in relation_path:
                     parts = relation_path.split("__", 1)
-                    if parts[0] == attr_name or attr_name == parts[0]:
+                    if parts[0] == attr_name:
                         result[attr_name]["nested"].append(parts[1])
             else:
                 attr_name = lookup.split("__")[0]
@@ -573,6 +447,8 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
         nested_relations: list[str],
         parent_pks: list[Any],
         main_results: list[dict[str, Any]],
+        *,
+        container: _ContainerType = dict,
     ) -> dict[Any, list[dict[str, Any]] | dict[str, Any] | None]:
         """Fetch a related model's data and group by parent PK."""
         relation_name = (
@@ -598,14 +474,11 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
             parent_path="",
             parent_data={r[pk_name]: r for r in main_results},
             custom_qs=custom_qs,
+            container=container,
         )
 
     def _get_select_related_from_queryset(self, qs: QuerySet[Any, Any] | None) -> dict[str, Any]:
-        """Get select_related structure from a queryset.
-
-        Returns a dict like {'publisher': {}, 'publisher__country': {}} for
-        select_related('publisher', 'publisher__country').
-        """
+        """Get select_related structure from a queryset."""
         if qs is None:
             return {}
 
@@ -614,15 +487,12 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
             return {}
 
         if select_related is True:
-            # select_related() with no args - get all FK fields
             result: dict[str, Any] = {}
             for field in qs.model._meta.concrete_fields:
                 if isinstance(field, ForeignKey):
                     result[field.name] = {}
             return result
 
-        # select_related is a nested dict like {'publisher': {'country': {}}}
-        # Flatten it to paths
         result = {}
         self._flatten_select_related_to_paths(select_related, "", result)
         return result
@@ -651,12 +521,10 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
         main_results: list[dict[str, Any]] | None,
         parent_path: str,
         m2m_field: ManyToManyField[Any, Any] | ManyToManyRel,
+        *,
+        container: _ContainerType = dict,
     ) -> dict[Any, list[dict[str, Any]]]:
-        """Fetch M2M data for forward/reverse M2M lookups, top-level and nested.
-
-        Use Django's compiler with .extra() annotation to match Django's native
-        prefetch_related behavior. Raw rows → dicts, no model instantiation.
-        """
+        """Fetch M2M data for forward/reverse M2M lookups."""
         related_pk_name = related_model._meta.pk.name
 
         if custom_qs is not None:
@@ -666,7 +534,6 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
 
         actual_field = m2m_field.field if isinstance(m2m_field, ManyToManyRel) else m2m_field
 
-        # Add extra select for parent FK (matching Django's prefetch approach)
         through_model = actual_field.remote_field.through
         assert through_model is not None  # noqa: S101
         source_field_name = (
@@ -679,23 +546,24 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
         extra_select = {
             f"_prefetch_related_val_{f.attname}": f"{qn(join_table)}.{qn(f.column)}" for f in fk.local_related_fields
         }
-        related_qs = related_qs.extra(select=extra_select)  # noqa: S610  # safe: identifiers quoted via qn()
+        related_qs = related_qs.extra(select=extra_select)  # noqa: S610
 
-        dicts, extra_values = _execute_prefetch_as_dicts(related_qs, self.db)
-        if not dicts:
+        # Build directly into container (dict or AttrDict) - no conversion needed
+        containers, extra_values = _execute_prefetch(related_qs, self.db, container)
+        if not containers:
             return {pk: [] for pk in parent_pks}
 
         result: dict[Any, list[dict[str, Any]]] = {pk: [] for pk in parent_pks}
         related_data: dict[Any, dict[str, Any]] = {}
 
-        for row_dict, extra_vals in zip(dicts, extra_values, strict=True):
+        for row_container, extra_vals in zip(containers, extra_values, strict=True):
             source_pk = next(iter(extra_vals.values())) if extra_vals else None
             if source_pk in result:
-                result[source_pk].append(row_dict)
+                result[source_pk].append(row_container)
 
-            related_pk = row_dict.get(related_pk_name)
+            related_pk = row_container.get(related_pk_name)
             if nested_relations and related_pk not in related_data:
-                related_data[related_pk] = row_dict
+                related_data[related_pk] = row_container
 
         if nested_relations and related_data:
             select_related_paths = self._get_select_related_from_queryset(custom_qs)
@@ -709,6 +577,7 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
                     list(related_data.keys()),
                     main_results,
                     f"{full_path}__",
+                    container=container,
                 )
                 for items in result.values():
                     for item in items:
@@ -730,18 +599,21 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
         custom_qs: QuerySet[Any, Any] | None,
         main_results: list[dict[str, Any]] | None,
         parent_path: str,
+        *,
+        container: _ContainerType = dict,
     ) -> dict[Any, list[dict[str, Any]]]:
-        """Fetch reverse FK data. Raw rows → dicts, no model instantiation."""
+        """Fetch reverse FK data."""
         related_pk_name = related_model._meta.pk.name
         fk_field = related_model._meta.get_field(fk_field_name)
-        fk_attname = fk_field.attname  # type: ignore[union-attr]  # e.g., 'book_id'
+        fk_attname = fk_field.attname  # type: ignore[union-attr]
 
         if custom_qs is not None:
             related_qs = custom_qs.filter(**{f"{fk_field_name}__in": parent_pks})
         else:
             related_qs = related_model._default_manager.filter(**{f"{fk_field_name}__in": parent_pks})
 
-        related_data = _execute_queryset_as_dicts(related_qs, self.db)
+        # Build directly into container (dict or AttrDict)
+        related_data = _execute_queryset(related_qs, self.db, container)
         if not related_data:
             return {pk: [] for pk in parent_pks}
 
@@ -752,14 +624,14 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
                 related_pks = [r[related_pk_name] for r in related_data]
                 nested_dict = {r[related_pk_name]: r for r in related_data}
                 full_path = f"{parent_path}{relation_name}" if parent_path else relation_name
-                new_parent_path = f"{full_path}__"
                 self._add_nested_relations(
                     related_model,
                     nested_dict,
                     remaining_nested,
                     related_pks,
                     main_results,
-                    new_parent_path,
+                    f"{full_path}__",
+                    container=container,
                 )
                 related_data = list(nested_dict.values())
 
@@ -767,9 +639,10 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
         for row in related_data:
             parent_pk = row.get(fk_attname)
             if parent_pk in result:
-                row_dict = dict(row)
-                row_dict.pop(fk_attname, None)  # Remove FK attname from output
-                result[parent_pk].append(row_dict)
+                # Remove FK attname from output
+                if fk_attname in row:
+                    del row[fk_attname]
+                result[parent_pk].append(row)
 
         return result
 
@@ -783,8 +656,10 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
         main_results: list[dict[str, Any]] | None,
         parent_path: str,
         parent_model: type[Model] | None = None,
+        *,
+        container: _ContainerType = dict,
     ) -> dict[Any, dict[str, Any] | None]:
-        """Fetch FK data. Raw rows → dicts, no model instantiation."""
+        """Fetch FK data."""
         related_model = cast("type[Model]", field.related_model)
         fk_attname = field.attname
         relation_name = field.name
@@ -819,14 +694,14 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
             for row in parent_data.values():  # type: ignore[union-attr]
                 nested = row.get(relation_name)
                 if isinstance(nested, dict) and nested.get(related_pk_name) is not None:
-                    related_data[nested[related_pk_name]] = dict(nested)
+                    related_data[nested[related_pk_name]] = container(nested)
         else:
             if custom_qs is not None:
                 related_qs = custom_qs.filter(pk__in=fk_values)
             else:
                 related_qs = related_model._default_manager.filter(pk__in=fk_values)
 
-            results = _execute_queryset_as_dicts(related_qs, self.db)
+            results = _execute_queryset(related_qs, self.db, container)
             related_data = {r[related_pk_name]: r for r in results}
 
         if not related_data:
@@ -841,12 +716,13 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
                 fk_values,
                 main_results,
                 full_path,
+                container=container,
             )
 
         result: dict[Any, dict[str, Any] | None] = {}
         for parent_pk in parent_pks:
             fk_value = fk_data.get(parent_pk)
-            result[parent_pk] = dict(related_data[fk_value]) if fk_value in related_data else None
+            result[parent_pk] = container(related_data[fk_value]) if fk_value in related_data else None
 
         return result
 
@@ -859,8 +735,10 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
         custom_qs: QuerySet[Any, Any] | None,
         main_results: list[dict[str, Any]] | None,
         parent_path: str,
+        *,
+        container: _ContainerType = dict,
     ) -> dict[Any, list[dict[str, Any]]]:
-        """Fetch GenericRelation data for top-level and nested lookups."""
+        """Fetch GenericRelation data."""
         related_model = cast("type[Model]", field.related_model)
         ct_field_name = field.content_type_field_name
         obj_id_field_name = field.object_id_field_name
@@ -874,7 +752,7 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
         else:
             related_qs = related_model._default_manager.filter(**filter_kwargs)
 
-        related_data = _execute_queryset_as_dicts(related_qs, self.db)
+        related_data = _execute_queryset(related_qs, self.db, container)
 
         if nested_relations and related_data:
             related_pks = [r[related_pk_name] for r in related_data]
@@ -887,16 +765,19 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
                 related_pks,
                 main_results,
                 f"{full_path}__",
+                container=container,
             )
             related_data = list(nested_dict.values())
 
         result: dict[Any, list[dict[str, Any]]] = {pk: [] for pk in parent_pks}
         for row in related_data:
             parent_pk = row[obj_id_field_name]
-            row_dict = dict(row)
-            row_dict.pop(obj_id_field_name, None)
-            row_dict.pop(f"{ct_field_name}_id", None)
-            result[parent_pk].append(row_dict)
+            if obj_id_field_name in row:
+                del row[obj_id_field_name]
+            ct_key = f"{ct_field_name}_id"
+            if ct_key in row:
+                del row[ct_key]
+            result[parent_pk].append(row)
 
         return result
 
@@ -905,12 +786,10 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
         lookup: GenericPrefetch[Any],
         parent_pks: list[Any],
         main_results: list[dict[str, Any]],
+        *,
+        container: _ContainerType = dict,
     ) -> dict[Any, dict[str, Any] | None]:
-        """Fetch GenericForeignKey data using GenericPrefetch.
-
-        GenericForeignKey can point to different model types. GenericPrefetch
-        provides a list of querysets, one for each possible content type.
-        """
+        """Fetch GenericForeignKey data using GenericPrefetch."""
         gfk_attr = lookup.prefetch_to
         gfk_descriptor = getattr(self.model, gfk_attr, None)
         if not isinstance(gfk_descriptor, GenericForeignKey):
@@ -950,7 +829,7 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
             object_ids = [obj_id for _, obj_id in parent_obj_pairs]
 
             related_qs = qs.filter(pk__in=object_ids)
-            results = _execute_queryset_as_dicts(related_qs, self.db)
+            results = _execute_queryset(related_qs, self.db, container)
             related_data = {r[related_pk_name]: r for r in results}
 
             if qs._prefetch_related_lookups:  # type: ignore[attr-defined]
@@ -961,6 +840,7 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
                         qs._prefetch_related_lookups,  # type: ignore[attr-defined]
                         nested_pks,
                         list(related_data.values()),
+                        container=container,
                     )
                     for pk_val, row_data in related_data.items():
                         for attr, data_by_pk in nested_prefetched.items():
@@ -968,7 +848,7 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
 
             for parent_pk, obj_id in parent_obj_pairs:
                 if obj_id in related_data:
-                    result[parent_pk] = dict(related_data[obj_id])
+                    result[parent_pk] = container(related_data[obj_id])
 
         return result
 
@@ -978,14 +858,16 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
         prefetch_lookups: tuple[Any, ...],
         parent_pks: list[Any],
         main_results: list[dict[str, Any]],
+        *,
+        container: _ContainerType = dict,
     ) -> dict[str, dict[Any, list[dict[str, Any]] | dict[str, Any] | None]]:
-        """Fetch prefetched relations for a related model (used by GenericForeignKey)."""
+        """Fetch prefetched relations for a related model."""
         temp_qs = NestedValuesQuerySetMixin.__new__(NestedValuesQuerySetMixin)
         temp_qs.model = model
         temp_qs.db = self.db  # type: ignore[misc]
         temp_qs.query = model._default_manager.all().query
 
-        return temp_qs._fetch_all_prefetched(prefetch_lookups, parent_pks, main_results)
+        return temp_qs._fetch_all_prefetched(prefetch_lookups, parent_pks, main_results, container=container)
 
     def _add_nested_relations(  # noqa: PLR0913
         self,
@@ -995,6 +877,8 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
         parent_pks: list[Any],
         main_results: list[dict[str, Any]] | None = None,
         parent_path: str = "",
+        *,
+        container: _ContainerType = dict,
     ) -> None:
         """Fetch and add nested relation data to already-fetched parent data."""
         for nested_rel in nested_relations:
@@ -1015,6 +899,7 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
                 main_results=main_results,
                 parent_path=parent_path,
                 parent_data=data,
+                container=container,
             )
 
             for pk, row in data.items():
@@ -1030,10 +915,12 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
         parent_path: str = "",
         parent_data: dict[Any, dict[str, Any]] | None = None,
         custom_qs: QuerySet[Any, Any] | None = None,
+        *,
+        container: _ContainerType = dict,
     ) -> dict[Any, list[dict[str, Any]] | dict[str, Any] | None]:
         """Dispatch to the appropriate fetch method based on field type."""
         if isinstance(field, ManyToManyField):
-            return self._fetch_m2m_internal(
+            return self._fetch_m2m_internal(  # type: ignore[return-value]
                 related_model=cast("type[Model]", field.related_model),
                 accessor=field.related_query_name(),
                 relation_name=field.name,
@@ -1043,9 +930,10 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
                 main_results=main_results,
                 parent_path=parent_path,
                 m2m_field=field,
-            )  # type: ignore[return-value]
+                container=container,
+            )
         if isinstance(field, ManyToOneRel):
-            return self._fetch_reverse_fk_internal(
+            return self._fetch_reverse_fk_internal(  # type: ignore[return-value]
                 related_model=cast("type[Model]", field.related_model),
                 fk_field_name=field.field.name,
                 relation_name=field.get_accessor_name() or field.name,
@@ -1054,9 +942,10 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
                 custom_qs=custom_qs,
                 main_results=main_results,
                 parent_path=parent_path,
-            )  # type: ignore[return-value]
+                container=container,
+            )
         if isinstance(field, ForeignKey):
-            return self._fetch_fk_internal(
+            return self._fetch_fk_internal(  # type: ignore[return-value]
                 field=field,
                 nested_relations=nested_relations,
                 parent_pks=parent_pks,
@@ -1065,9 +954,10 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
                 main_results=main_results,
                 parent_path=parent_path,
                 parent_model=parent_model,
-            )  # type: ignore[return-value]
+                container=container,
+            )
         if isinstance(field, ManyToManyRel):
-            return self._fetch_m2m_internal(
+            return self._fetch_m2m_internal(  # type: ignore[return-value]
                 related_model=cast("type[Model]", field.related_model),
                 accessor=field.field.name,
                 relation_name=field.get_accessor_name() or field.name,
@@ -1077,9 +967,10 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
                 main_results=main_results,
                 parent_path=parent_path,
                 m2m_field=field,
-            )  # type: ignore[return-value]
+                container=container,
+            )
         if isinstance(field, GenericRelation):
-            return self._fetch_generic_relation_internal(
+            return self._fetch_generic_relation_internal(  # type: ignore[return-value]
                 field,
                 nested_relations,
                 parent_pks,
@@ -1087,7 +978,8 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
                 custom_qs,
                 main_results,
                 parent_path,
-            )  # type: ignore[return-value]
+                container=container,
+            )
         return {}
 
     def _is_many_relation(self, field: Any) -> bool:
@@ -1098,22 +990,14 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
 class NestedValuesQuerySet(NestedValuesQuerySetMixin[_ModelT_co], QuerySet[_ModelT_co, _ModelT_co]):
     """QuerySet that adds .values_nested() for nested dictionaries.
 
-    This is a ready-to-use QuerySet combining NestedValuesQuerySetMixin with Django's QuerySet.
-
     Usage:
         class Book(models.Model):
             objects = NestedValuesQuerySet.as_manager()
 
-        # Use standard Django patterns:
-        Book.objects.only("title").select_related("publisher").prefetch_related("authors").values_nested()
+        Book.objects.select_related("publisher").prefetch_related("authors").values_nested()
         # Returns: [{'id': 1, 'title': '...', 'publisher': {...}, 'authors': [...]}, ...]
 
-    If you have a custom QuerySet, use NestedValuesQuerySetMixin instead:
-
-        class MyQuerySet(NestedValuesQuerySetMixin, QuerySet):
-            def my_custom_method(self):
-                ...
-
-    Type hints: The queryset is generic over the model type. After calling values_nested(),
-    it yields dict[str, Any] when iterated, similar to Django's values() method.
+    With attribute access:
+        Book.objects.values_nested(as_attr_dicts=True)
+        # Returns AttrDict instances: book.title, book.publisher.name work
     """

{django_nested_values-0.6.14 → django_nested_values-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "django-nested-values"
-version = "0.6.14"
+version = "0.7.0"
 description = "Add .values_nested() to Django querysets for nested prefetch dictionaries"
 readme = "README.md"
 license = { text = "MIT" }