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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-nested-values
-Version: 0.7.0
+Version: 1.0.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.7.0 → django_nested_values-1.0.0}/django_nested_values/__init__.py

@@ -1,10 +1,9 @@
 """Django Nested Values - Enable .prefetch_related().values_nested() in Django ORM."""
 
 from django_nested_values.queryset import (
-    AttrDict,
     NestedValuesQuerySet,
     NestedValuesQuerySetMixin,
 )
 
-__all__ = ["AttrDict", "NestedValuesQuerySet", "NestedValuesQuerySetMixin"]
-__version__ = "0.7.0"
+__all__ = ["NestedValuesQuerySet", "NestedValuesQuerySetMixin"]
+__version__ = "1.0.0"

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

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Generic, Literal, Self, TypeVar, cast, overload
+from typing import TYPE_CHECKING, Any, Generic, Self, TypeVar, cast
 
 from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
 from django.contrib.contenttypes.models import ContentType
@@ -15,40 +15,10 @@ 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
+# Type alias for dict-like container classes (kept for future custom container support)
 _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
 
@@ -67,7 +37,7 @@ def _build_from_klass_info(
     select: list[tuple[Any, ...]],
     container: _ContainerType = dict,
 ) -> dict[str, Any]:
-    """Build a dict (or dict subclass like AttrDict) directly from a row.
+    """Build a dict directly from a row using Django's compiler metadata.
 
     This uses Django's internal compiler metadata to know exactly which
     columns belong to which model, avoiding manual field path parsing.
@@ -76,7 +46,7 @@ def _build_from_klass_info(
         row: A tuple of values from the database row
         klass_info: The klass_info dict from compiler
         select: The compiler.select list
-        container: The dict-like class to use (dict or AttrDict)
+        container: The dict-like class to use for results
 
     Returns:
         A container instance with field names as keys
@@ -92,6 +62,8 @@ def _build_from_klass_info(
     for related_ki in klass_info.get("related_klass_infos", []):
         pk_idx = related_ki["select_fields"][0]
         if row[pk_idx] is None:
+            # Include NULL FK as None rather than omitting the key
+            result[related_ki["field"].name] = None
             continue
         result[related_ki["field"].name] = _build_from_klass_info(row, related_ki, select, container)
 
@@ -103,12 +75,12 @@ def _execute_queryset(
     db: str,
     container: _ContainerType = dict,
 ) -> list[dict[str, Any]]:
-    """Execute a queryset and return results as nested dicts (or AttrDict).
+    """Execute a queryset and return results as nested dicts.
 
     Args:
         queryset: The queryset to execute
         db: Database alias to use
-        container: The dict-like class to use (dict or AttrDict)
+        container: The dict-like class to use for results
 
     Returns:
         List of nested containers, one per row
@@ -141,7 +113,7 @@ def _execute_prefetch(
     Args:
         queryset: The queryset to execute
         db: Database alias to use
-        container: The dict-like class to use (dict or AttrDict)
+        container: The dict-like class to use for results
 
     Returns:
         Tuple of (list of model containers, list of extra column dicts for grouping)
@@ -190,7 +162,7 @@ class NestedValuesIterable(BaseIterable):  # type: ignore[type-arg]
         queryset: NestedValuesQuerySetMixin[Any]
 
     def __iter__(self) -> Iterator[dict[str, Any]]:
-        """Iterate over the queryset, yielding nested dictionaries (or AttrDict)."""
+        """Iterate over the queryset, yielding nested dictionaries."""
         queryset = self.queryset
         db = queryset.db
         prefetch_lookups = getattr(queryset, "_nested_prefetch_lookups", ())
@@ -211,12 +183,11 @@ class NestedValuesIterable(BaseIterable):  # type: ignore[type-arg]
         if klass_info is None:
             return
 
-        # 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]
+        # Container class for results (kept configurable for potential future use)
+        container: _ContainerType = dict
         pk_name = queryset.model._meta.pk.name
 
-        # Build main results - unified path for both dict and AttrDict
+        # Build main results from database rows
         main_results = [
             _build_from_klass_info(row, klass_info, select, container) for row in compiler.results_iter(results)
         ]
@@ -320,48 +291,22 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
     """
 
     _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]
         clone._nested_prefetch_lookups = self._nested_prefetch_lookups
-        clone._as_attr_dicts = self._as_attr_dicts
         return clone
 
-    @overload
-    def values_nested(
-        self,
-        *,
-        as_attr_dicts: Literal[False] = ...,
-    ) -> QuerySet[_ModelT_co, dict[str, Any]]: ...
-
-    @overload
-    def values_nested(
-        self,
-        *,
-        as_attr_dicts: Literal[True],
-    ) -> QuerySet[_ModelT_co, AttrDict]: ...
-
-    def values_nested(
-        self,
-        *,
-        as_attr_dicts: bool = False,
-    ) -> QuerySet[_ModelT_co, dict[str, Any]] | QuerySet[_ModelT_co, AttrDict]:
+    def values_nested(self) -> QuerySet[_ModelT_co, dict[str, Any]]:
         """Return nested dictionaries with related objects included.
 
-        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"]).
-
         Returns:
-            A QuerySet that yields dict[str, Any] or AttrDict when iterated.
+            A QuerySet that yields dict[str, Any] when iterated.
 
         """
         clone: Self = self._clone()  # type: ignore[assignment]
         clone._iterable_class = NestedValuesIterable
-        clone._as_attr_dicts = as_attr_dicts
         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]
@@ -548,7 +493,7 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
         }
         related_qs = related_qs.extra(select=extra_select)  # noqa: S610
 
-        # Build directly into container (dict or AttrDict) - no conversion needed
+        # Build directly into container - no conversion needed
         containers, extra_values = _execute_prefetch(related_qs, self.db, container)
         if not containers:
             return {pk: [] for pk in parent_pks}
@@ -612,7 +557,7 @@ class NestedValuesQuerySetMixin(_MixinBase[_ModelT_co]):
         else:
             related_qs = related_model._default_manager.filter(**{f"{fk_field_name}__in": parent_pks})
 
-        # Build directly into container (dict or AttrDict)
+        # Build directly into container
         related_data = _execute_queryset(related_qs, self.db, container)
         if not related_data:
             return {pk: [] for pk in parent_pks}
@@ -996,8 +941,4 @@ class NestedValuesQuerySet(NestedValuesQuerySetMixin[_ModelT_co], QuerySet[_Mode
 
         Book.objects.select_related("publisher").prefetch_related("authors").values_nested()
         # Returns: [{'id': 1, 'title': '...', 'publisher': {...}, 'authors': [...]}, ...]
-
-    With attribute access:
-        Book.objects.values_nested(as_attr_dicts=True)
-        # Returns AttrDict instances: book.title, book.publisher.name work
     """

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

@@ -1,6 +1,6 @@
 [project]
 name = "django-nested-values"
-version = "0.7.0"
+version = "1.0.0"
 description = "Add .values_nested() to Django querysets for nested prefetch dictionaries"
 readme = "README.md"
 license = { text = "MIT" }
@@ -63,7 +63,7 @@ dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
 explicit-preview-rules = true
 fixable = ["ALL"]
 ignore = [
-  "ANN401", # Any needed for AttrDict's dynamic attribute access
+  "ANN401", # Any needed for dynamic dict values and Django internals
   "COM812", # Conflicts with ruff-format
   "E5",     # 120 char limit is sufficient
   "SLF001", # Private member access needed for Django internals