djhtmx 1.3.2__tar.gz → 1.3.3__tar.gz

{djhtmx-1.3.2 → djhtmx-1.3.3}/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.3.3] - 2026-01-14
+
+### Fixed
+- **Lazy Model Deleted Object Handling**: Fixed lazy models to gracefully handle deleted database objects:
+  - Required lazy models (`Annotated[Model, ModelConfig(lazy=True)]`): Raise clear `ObjectDoesNotExist` exception when checking truthiness if object was deleted
+  - Optional lazy models (`Annotated[Model | None, ModelConfig(lazy=True)]`): Become falsy and return `None` for field accesses when object was deleted
+  - Accessing `.pk` on lazy proxies always works without triggering database queries, even for deleted objects
+- **ModelConfig Extraction**: Fixed `annotate_model()` to properly extract and apply `ModelConfig` from `Annotated` type metadata. Previously, `ModelConfig` in annotations like `Annotated[Item, ModelConfig(lazy=True)]` was ignored.
+
+### Added
+- Comprehensive test coverage for lazy model deleted object handling using real `HtmxComponent` with user-facing API
+- `__bool__()` method on `_LazyModelProxy` to detect deleted objects immediately when checking truthiness
+
 ## [1.3.2] - 2026-01-14
 
 ### Fixed

{djhtmx-1.3.2 → djhtmx-1.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: djhtmx
-Version: 1.3.2
+Version: 1.3.3
 Summary: Interactive UI Components for Django using HTMX
 Project-URL: Homepage, https://github.com/edelvalle/djhtmx
 Project-URL: Documentation, https://github.com/edelvalle/djhtmx#readme
@@ -311,6 +311,23 @@ class TodoComponent(HtmxComponent):
     ]
 ```
 
+**Handling Deleted Objects:**
+
+Lazy models handle deleted database objects gracefully:
+
+```python
+class MyComponent(HtmxComponent):
+    # Required: raises ObjectDoesNotExist when checking if object was deleted
+    item: Annotated[Item, ModelConfig(lazy=True)]
+
+    # Optional: becomes falsy and returns None when object was deleted
+    archived_item: Annotated[Item | None, ModelConfig(lazy=True)]
+```
+
+- **Required lazy models**: Checking truthiness (`if component.item:`) raises `ObjectDoesNotExist` with a clear message
+- **Optional lazy models**: Checking truthiness returns `False`, field accesses return `None`
+- **Both**: Accessing `.pk` always works without triggering database queries
+
 ## Component nesting
 
 Components can contain components inside to decompose the behavior in more granular and specialized parts, for this you don't have to do anything but to a component inside the template of other component....

{djhtmx-1.3.2 → djhtmx-1.3.3}/README.md

@@ -264,6 +264,23 @@ class TodoComponent(HtmxComponent):
     ]
 ```
 
+**Handling Deleted Objects:**
+
+Lazy models handle deleted database objects gracefully:
+
+```python
+class MyComponent(HtmxComponent):
+    # Required: raises ObjectDoesNotExist when checking if object was deleted
+    item: Annotated[Item, ModelConfig(lazy=True)]
+
+    # Optional: becomes falsy and returns None when object was deleted
+    archived_item: Annotated[Item | None, ModelConfig(lazy=True)]
+```
+
+- **Required lazy models**: Checking truthiness (`if component.item:`) raises `ObjectDoesNotExist` with a clear message
+- **Optional lazy models**: Checking truthiness returns `False`, field accesses return `None`
+- **Both**: Accessing `.pk` always works without triggering database queries
+
 ## Component nesting
 
 Components can contain components inside to decompose the behavior in more granular and specialized parts, for this you don't have to do anything but to a component inside the template of other component....

{djhtmx-1.3.2 → djhtmx-1.3.3}/src/djhtmx/__init__.py

@@ -1,4 +1,4 @@
 from .middleware import middleware
 
-__version__ = "1.3.2"
+__version__ = "1.3.3"
 __all__ = ("middleware",)

{djhtmx-1.3.2 → djhtmx-1.3.3}/src/djhtmx/introspection.py

@@ -78,12 +78,14 @@ class _LazyModelProxy(Generic[M]):  # noqa
     __pk: Any | None
     __select_related: Sequence[str] | None
     __prefetch_related: Sequence[str | Prefetch] | None
+    __allow_none: bool
 
     def __init__(
         self,
         model: type[M],
         value: Any,
         model_annotation: ModelConfig | None = None,
+        allow_none: bool = False,
     ):
         self.__model = model
         if value is None or isinstance(value, model):
@@ -98,12 +100,44 @@ class _LazyModelProxy(Generic[M]):  # noqa
         else:
             self.__select_related = None
             self.__prefetch_related = None
+        self.__allow_none = allow_none
+
+    def __bool__(self) -> bool:
+        """Check if the instance exists. Called when proxy is used in boolean context."""
+        if self.__instance is None:
+            self.__ensure_instance()
+            if self.__instance is None:
+                # Object doesn't exist
+                if not self.__allow_none:
+                    # Required field - raise exception
+                    from django.core.exceptions import ObjectDoesNotExist
+
+                    raise ObjectDoesNotExist(
+                        f"{self.__model.__name__} with pk={self.__pk} does not exist "
+                        "(object may have been deleted)"
+                    )
+                # Optional field - return False (proxy is falsy)
+                return False
+        return True
 
     def __getattr__(self, name: str) -> Any:
         if name == "pk":
             return self.__pk
         if self.__instance is None:
             self.__ensure_instance()
+            if self.__instance is None:
+                # Object doesn't exist (was deleted or never existed)
+                if self.__allow_none:
+                    # Optional field (Model | None) - return None gracefully
+                    return None
+                else:
+                    # Required field (Model) - raise explicit exception
+                    from django.core.exceptions import ObjectDoesNotExist
+
+                    raise ObjectDoesNotExist(
+                        f"{self.__model.__name__} with pk={self.__pk} does not exist "
+                        "(object may have been deleted)"
+                    )
         return getattr(self.__instance, name)
 
     def __ensure_instance(self):
@@ -143,9 +177,13 @@ class _ModelBeforeValidator(Generic[M]):  # noqa
             return None
         elif isinstance(value, _LazyModelProxy):
             instance = value._LazyModelProxy__instance or value._LazyModelProxy__pk
-            return _LazyModelProxy(self.model, instance, model_annotation=self.model_config)
+            return _LazyModelProxy(
+                self.model, instance, model_annotation=self.model_config, allow_none=self.allow_none
+            )
         else:
-            return _LazyModelProxy(self.model, value, model_annotation=self.model_config)
+            return _LazyModelProxy(
+                self.model, value, model_annotation=self.model_config, allow_none=self.allow_none
+            )
 
     def _get_instance(self, value):
         if value is None or isinstance(value, self.model):
@@ -254,7 +292,16 @@ def annotate_model(annotation, *, model_config: ModelConfig | None = None):
                 # Process the base type (first arg) and keep other metadata
                 base_type = args[0]
                 metadata = args[1:]
-                processed_base = annotate_model(base_type, model_config=model_config)
+
+                # Extract ModelConfig from metadata if present
+                extracted_model_config = next(
+                    (m for m in metadata if isinstance(m, ModelConfig)),
+                    None,
+                )
+                # Use extracted config, falling back to passed parameter
+                config_to_use = extracted_model_config or model_config
+
+                processed_base = annotate_model(base_type, model_config=config_to_use)
 
                 # If processed_base is also Annotated, merge the metadata
                 if get_origin(processed_base) is Annotated: