djhtmx 1.3.3__py3-none-any.whl → 1.3.5__py3-none-any.whl

djhtmx/__init__.py

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

djhtmx/introspection.py

@@ -29,7 +29,6 @@ from django.db import models
 from django.db.models import Prefetch
 from django.utils.datastructures import MultiValueDict
 from pydantic import BeforeValidator, PlainSerializer, TypeAdapter
-from pydantic_core import PydanticCustomError
 
 M = TypeVar("M", bound=models.Model)
 
@@ -88,6 +87,7 @@ class _LazyModelProxy(Generic[M]):  # noqa
         allow_none: bool = False,
     ):
         self.__model = model
+        self.__allow_none = allow_none
         if value is None or isinstance(value, model):
             self.__instance = value
             self.__pk = getattr(value, "pk", None)
@@ -100,60 +100,31 @@ 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):
-        if self.__instance:
-            return self.__instance
-        elif self.__pk is None:
-            # If pk is None, don't try to load anything
-            return None
-        else:
+        if not self.__instance:
             manager = self.__model.objects
             if select_related := self.__select_related:
                 manager = manager.select_related(*select_related)
             if prefetch_related := self.__prefetch_related:
                 manager = manager.prefetch_related(*prefetch_related)
+            # Use filter().first() instead of get() to avoid exceptions
             self.__instance = manager.filter(pk=self.__pk).first()
-            return self.__instance
+            if self.__instance is None:
+                if self.__allow_none:
+                    # For Model | None, object doesn't exist - proxy becomes None-like
+                    pass
+                else:
+                    # For required Model fields, raise error
+                    raise ValueError(f"{self.__model.__name__} with pk={self.__pk} does not exist")
+        return self.__instance
 
     def __repr__(self) -> str:
         return f"<_LazyModelProxy model={self.__model}, pk={self.__pk}, instance={self.__instance}>"
@@ -172,18 +143,11 @@ class _ModelBeforeValidator(Generic[M]):  # noqa
             return self._get_instance(value)
 
     def _get_lazy_proxy(self, value):
-        if value is None:
-            # Don't create a proxy for explicit None
-            return None
-        elif isinstance(value, _LazyModelProxy):
+        if isinstance(value, _LazyModelProxy):
             instance = value._LazyModelProxy__instance or value._LazyModelProxy__pk
-            return _LazyModelProxy(
-                self.model, instance, model_annotation=self.model_config, allow_none=self.allow_none
-            )
+            return _LazyModelProxy(self.model, instance, allow_none=self.allow_none)
         else:
-            return _LazyModelProxy(
-                self.model, value, model_annotation=self.model_config, allow_none=self.allow_none
-            )
+            return _LazyModelProxy(self.model, value, allow_none=self.allow_none)
 
     def _get_instance(self, value):
         if value is None or isinstance(value, self.model):
@@ -206,11 +170,7 @@ class _ModelBeforeValidator(Generic[M]):  # noqa
                     return None
                 else:
                     # For required Model fields, raise validation error
-                    raise PydanticCustomError(
-                        "model_not_found",
-                        f"{self.model.__name__} with pk={{pk}} does not exist",
-                        {"pk": value},
-                    )
+                    raise ValueError(f"{self.model.__name__} with pk={value} does not exist")
             return instance
 
     @classmethod
@@ -224,11 +184,7 @@ class _ModelPlainSerializer(Generic[M]):  # noqa
     model: type[M]
 
     def __call__(self, value):
-        # Handle None for Model | None fields
-        if value is None:
-            return None
-        else:
-            return value.pk
+        return value.pk
 
     @classmethod
     @cache
@@ -237,16 +193,20 @@ class _ModelPlainSerializer(Generic[M]):  # noqa
 
 
 def _Model(
-    model: type[models.Model], model_config: ModelConfig | None = None, allow_none: bool = False
+    model: type[models.Model],
+    model_config: ModelConfig | None = None,
+    allow_none: bool = False,
 ):
     assert issubclass_safe(model, models.Model)
     model_config = model_config or _DEFAULT_MODEL_CONFIG
+
+    # Determine the base type
     base_type = model if not model_config.lazy else _LazyModelProxy[model]
-    # If allow_none is True, the base type can be None (for Model | None unions)
-    if allow_none:
-        base_type = base_type | None  # type: ignore
+    # If allow_none, make it optional
+    annotated_type = base_type | None if allow_none else base_type
+
     return Annotated[
-        base_type,
+        annotated_type,
         BeforeValidator(_ModelBeforeValidator.from_modelclass(model, model_config, allow_none)),
         PlainSerializer(
             func=_ModelPlainSerializer.from_modelclass(model),
@@ -285,63 +245,45 @@ def annotate_model(annotation, *, model_config: ModelConfig | None = None):
             },
         )
     elif type_ := get_origin(annotation):
-        # Handle Annotated types like Annotated[Item | None, Query("editing")]
-        if type_ is Annotated:
-            args = get_args(annotation)
-            if args:
-                # Process the base type (first arg) and keep other metadata
-                base_type = args[0]
-                metadata = args[1:]
-
-                # Extract ModelConfig from metadata if present
-                extracted_model_config = next(
-                    (m for m in metadata if isinstance(m, ModelConfig)),
+        if type_ is types.UnionType or type_ is Union:
+            type_ = Union
+        match get_args(annotation):
+            case ():
+                return type_
+            case (param,):
+                return type_[annotate_model(param)]  # type: ignore
+            case params:
+                # Check for ModelConfig in params (for Annotated types)
+                param_model_config = next(
+                    (p for p in params if isinstance(p, 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:
-                    processed_args = get_args(processed_base)
-                    inner_base = processed_args[0]
-                    inner_metadata = processed_args[1:]
-                    # Merge: inner metadata first, then original metadata
-                    return Annotated[inner_base, *inner_metadata, *metadata]  # type: ignore
+                # Use param ModelConfig if found, otherwise use the passed model_config
+                effective_model_config = param_model_config or model_config
+
+                # Check if this is a Model | None union
+                has_none = types.NoneType in params
+                model_types = [p for p in params if issubclass_safe(p, models.Model)]
+
+                # If we have Model | None, annotate the model with allow_none=True
+                if has_none and len(model_types) == 1:
+                    annotated_params = []
+                    for p in params:
+                        if issubclass_safe(p, models.Model):
+                            annotated_params.append(
+                                _Model(p, effective_model_config, allow_none=True)
+                            )
+                        elif p is not types.NoneType:
+                            annotated_params.append(
+                                annotate_model(p, model_config=effective_model_config)
+                            )
+                        else:
+                            annotated_params.append(p)
+                    return type_[*annotated_params]  # type: ignore
                 else:
-                    # Reconstruct the Annotated with processed base type
-                    return Annotated[processed_base, *metadata]  # type: ignore
-            return annotation
-        elif type_ is types.UnionType or type_ is Union:
-            type_ = Union
-            match get_args(annotation):
-                case ():
-                    return type_
-                case (param,):
-                    return type_[annotate_model(param)]  # type: ignore
-                case params:
-                    model_annotation = next(
-                        (p for p in params if isinstance(p, ModelConfig)),
-                        None,
-                    )
-                    # Check if this is a Model | None union
-                    has_none = types.NoneType in params
-                    model_params = [p for p in params if issubclass_safe(p, models.Model)]
-
-                    if has_none and len(model_params) == 1:
-                        # This is a Model | None union - use allow_none=True
-                        # Use the model_config parameter passed to annotate_model, not model_annotation from Union params
-                        model = model_params[0]
-                        return _Model(model, model_config or model_annotation, allow_none=True)
-                    else:
-                        # Regular union - process each param independently
-                        return type_[
-                            *(annotate_model(p, model_config=model_annotation) for p in params)
-                        ]  # type: ignore
-        # Other generic types (list, dict, defaultdict, etc.) - return as-is
-        return annotation
+                    return type_[
+                        *(annotate_model(p, model_config=effective_model_config) for p in params)
+                    ]  # type: ignore
     else:
         return annotation
 
@@ -519,27 +461,10 @@ def is_basic_type(ann):
     - Literal types with simple values
 
     """
-    # Check if it's a Union (e.g., Item | None)
-    origin_type = get_origin(ann)
-    if origin_type in (types.UnionType, Union):
-        args = get_args(ann)
-        # If it's Model | None, consider it a basic type
-        model_types = [arg for arg in args if issubclass_safe(arg, models.Model)]
-        if model_types and types.NoneType in args:
-            return True
-
-    # Check for Annotated[Model, ...] or Annotated[Model | None, ...] pattern
-    origin = getattr(ann, "__origin__", None)
-    if origin is not None and get_origin(origin) in (types.UnionType, Union):
-        args = get_args(origin)
-        model_types = [arg for arg in args if issubclass_safe(arg, models.Model)]
-        if model_types and types.NoneType in args:
-            return True
-
     return (
         ann in _SIMPLE_TYPES
         #  __origin__ -> model in 'Annotated[model, BeforeValidator(...), PlainSerializer(...)]'
-        or issubclass_safe(origin, models.Model)
+        or issubclass_safe(getattr(ann, "__origin__", None), models.Model)
         or issubclass_safe(ann, (enum.IntEnum, enum.StrEnum))
         or is_collection_annotation(ann)
         or is_literal_annotation(ann)

djhtmx/repo.py

@@ -240,7 +240,11 @@ class Repository:
                                 Emit(HtmxUnhandledError(error, handler_annotations=annotations))
                             ]
                         yield from self._process_emited_commands(
-                            component, emited_commands, commands, during_execute=True
+                            component,
+                            emited_commands,
+                            commands,
+                            during_execute=True,
+                            method_name=event_handler,
                         )
 
             case SkipRender(component):
@@ -286,7 +290,11 @@ class Repository:
                         else:
                             raise
                     yield from self._process_emited_commands(
-                        component, emited_commands, commands, during_execute=False
+                        component,
+                        emited_commands,
+                        commands,
+                        during_execute=False,
+                        method_name="_handle_event",
                     )
 
             case Signal(signals):
@@ -320,10 +328,13 @@ class Repository:
         emmited_commands: Iterable[Command] | None,
         commands: CommandQueue,
         during_execute: bool,
+        method_name: str | None = None,
     ) -> Iterable[ProcessedCommand]:
         component_was_rendered = False
         commands_to_add: list[Command] = []
         for command in emmited_commands or []:
+            if method_name:
+                logger.debug("< YIELD: %s.%s -> %s", component.hx_name, method_name, command)
             component_was_rendered = component_was_rendered or (
                 isinstance(command, SkipRender | Render) and command.component.id == component.id
             )

djhtmx/templatetags/htmx.py

@@ -292,4 +292,4 @@ class ClassNode(Node):
             for condition, class_name in self.condition_and_classes
             if condition.eval(context)  # type: ignore
         ]
-        return format_html_attrs({"class": " ".join(class_names) or None})
+        return format_html_attrs({"class": " ".join(filter(None, class_names)) or None})

djhtmx/utils.py

@@ -130,6 +130,8 @@ def autodiscover_htmx_modules():
     - All Python files under htmx/ directories in apps (recursively)
     """
     for app_config in apps.get_app_configs():
+        if app_config.module is None:
+            continue
         module_name = f"{app_config.module.__name__}.htmx"
         spec = importlib.util.find_spec(module_name)
         if spec is None:

{djhtmx-1.3.3.dist-info → djhtmx-1.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: djhtmx
-Version: 1.3.3
+Version: 1.3.5
 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

{djhtmx-1.3.3.dist-info → djhtmx-1.3.5.dist-info}/RECORD

@@ -1,4 +1,4 @@
-djhtmx/__init__.py,sha256=VL_7rY7fcdRsK0N7SZK5nteSMhURTdTtuExuNLQaZBs,84
+djhtmx/__init__.py,sha256=gh8Y_nLUObBD-XKDjwxAMcHUbqSpiLfbiBgXd3ZEzXk,84
 djhtmx/apps.py,sha256=hAyjzmInEstxLY9k8Qn58LvNlezgQLx5_NqyVL1WwYs,323
 djhtmx/command_queue.py,sha256=LSUkb2YMRt1lDyOg6WP7PoHsObynec0B55JyFtcshT0,5090
 djhtmx/commands.py,sha256=UxXbARd4Teetjh_zjvAWgI2KNbvdETH-WrGf4qD9Xr8,1206
@@ -7,16 +7,16 @@ djhtmx/consumer.py,sha256=0Yh8urgMH3khA6_pWeY049w3jqHWZL_K9dErOhNctQA,2898
 djhtmx/context.py,sha256=cWvz8Z0MC6x_G8sn5mvoH8Hu38qReY21_eNdThuba1A,214
 djhtmx/exceptions.py,sha256=UtyE1N-52OmzwgRM9xFxjUuhHTMDvD7Oy3rNpgthLcs,47
 djhtmx/global_events.py,sha256=bYb8WmQn_WsZ_Dadr0pGiGOPia01K-VanPpM97Lt324,342
-djhtmx/introspection.py,sha256=s1hJ5EO-DcLOZwBiZSUAcnBsCi1ewwPlER1cFPO1QNo,19907
+djhtmx/introspection.py,sha256=QZOaX7tWftMZCjRVXYGHxaCxSksoT2wljd3lIMaz9ic,16463
 djhtmx/json.py,sha256=7cjwWIJj7e0dk54INKYZJe6zKkIW7wlsNSlD05cbXfY,1374
 djhtmx/middleware.py,sha256=JuMtv9ZnpungTvQ1qD2Lg6LiFPB3knQlA1ERgH4iGl0,1274
 djhtmx/query.py,sha256=GKubKKZ1Z6krzLjG4GZpcxAyPy-pCMCtyfSVfXrpy90,6855
-djhtmx/repo.py,sha256=Qw8t9i5_upfvYJyUr4Cb9hZoI9WUHhNOpszxjhtx9r4,22478
+djhtmx/repo.py,sha256=BZrxLCxcqJudCsHvlL_bmkjhvbsFMAP7sZLCTxTRiCI,22906
 djhtmx/settings.py,sha256=Iti4LkcKBTy-dNyCZxFH_cUp56aTcXjB5ftbssWyDnU,1318
 djhtmx/testing.py,sha256=QmZHrH6Up8uUxkVOHM6CyfocU774GL-lopJvM2X9Mkw,8369
 djhtmx/tracing.py,sha256=xkCXb7t_3yCj1PGzmQfHPu9sYQftDKwtALaEbFVnQ1E,1260
 djhtmx/urls.py,sha256=2LTzmBCd3lBlQcM6WrdQwkITxuL_4ArUHtiYbLk3T1M,4273
-djhtmx/utils.py,sha256=PhFKUpDA6rS6kGkbkP3V0Md8-RQDEiARMoE6399KBy0,4649
+djhtmx/utils.py,sha256=XyRF3RD7_wOLIu6dVwxnUm828oGwKcPAbgq8oMd27m8,4708
 djhtmx/management/commands/htmx.py,sha256=tEtiJn_Z6byOFzBNIzTbdluA4T5q21zFwGvJ7yt90bw,3642
 djhtmx/static/htmx/django.js,sha256=QDgkUBiX9PBa_bqfK2k4NwjBAgZlxYEK-JklOgn_IR4,5453
 djhtmx/static/htmx/2.0.4/htmx.amd.js,sha256=Hgmm_X5zw7ek0pjBaxhzH7OHx6Xfce5UYVa9ICWlWR0,165593
@@ -30,8 +30,8 @@ djhtmx/static/htmx/2.0.4/ext/ws.js,sha256=HwUYFqEZBvs7Tx0_O0Bi-Dcmg5UOMlbMdkJ2FW
 djhtmx/templates/htmx/headers.html,sha256=z7r9klwBDXDyjbHrzatZeHDvXB2DaZhgu55CFbbD3d4,159
 djhtmx/templates/htmx/lazy.html,sha256=LfAThtKmFj-lCUZ7JWF_sC1Y6XsIpEz8A3IgWASn-J8,52
 djhtmx/templatetags/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-djhtmx/templatetags/htmx.py,sha256=-qFqz4T9mCJocG9XIIey81cCYwk07XUd_DMpxNdmbsM,8397
-djhtmx-1.3.3.dist-info/METADATA,sha256=5UCGB6iJel1PhQxBnImgvcGp-n6jgfhWUEmNtz68Bck,33745
-djhtmx-1.3.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-djhtmx-1.3.3.dist-info/licenses/LICENSE,sha256=kCi_iSBUGsRZInQn96w7LXYzjiRjZ8FXl6vP--mFRPk,1085
-djhtmx-1.3.3.dist-info/RECORD,,
+djhtmx/templatetags/htmx.py,sha256=apZqnFnCYjayj6ZwoQLr6TDgYU0834r3FhPhw3Q-8dU,8411
+djhtmx-1.3.5.dist-info/METADATA,sha256=5VMhn325lefcyL5DDC2CPzLluT74kaPGZqLzsec5fto,33745
+djhtmx-1.3.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+djhtmx-1.3.5.dist-info/licenses/LICENSE,sha256=kCi_iSBUGsRZInQn96w7LXYzjiRjZ8FXl6vP--mFRPk,1085
+djhtmx-1.3.5.dist-info/RECORD,,