plain.htmx 0.10.2__tar.gz → 0.10.3__tar.gz

{plain_htmx-0.10.2 → plain_htmx-0.10.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain.htmx
-Version: 0.10.2
+Version: 0.10.3
 Summary: Integrate HTMX with templates and views.
 Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
 License-Expression: BSD-3-Clause

{plain_htmx-0.10.2 → plain_htmx-0.10.3}/plain/htmx/CHANGELOG.md

@@ -1,5 +1,15 @@
 # plain-htmx changelog
 
+## [0.10.3](https://github.com/dropseed/plain/releases/plain-htmx@0.10.3) (2025-10-06)
+
+### What's changed
+
+- Added type annotations for improved IDE and type checker support ([8cdda13](https://github.com/dropseed/plain/commit/8cdda13a6c))
+
+### Upgrade instructions
+
+- No changes required
+
 ## [0.10.2](https://github.com/dropseed/plain/releases/plain-htmx@0.10.2) (2025-10-02)
 
 ### What's changed

{plain_htmx-0.10.2 → plain_htmx-0.10.3}/plain/htmx/templates.py

@@ -1,6 +1,12 @@
+from __future__ import annotations
+
+from typing import Any
+
 import jinja2
 from jinja2 import meta, nodes
 from jinja2.ext import Extension
+from jinja2.nodes import CallBlock, Node
+from jinja2.parser import Parser
 
 from plain.runtime import settings
 from plain.templates import register_template_extension
@@ -12,7 +18,9 @@ class HTMXJSExtension(InclusionTagExtension):
     tags = {"htmx_js"}
     template_name = "htmx/js.html"
 
-    def get_context(self, context, *args, **kwargs):
+    def get_context(
+        self, context: dict[str, Any], *args: Any, **kwargs: Any
+    ) -> dict[str, Any]:
         return {
             "DEBUG": settings.DEBUG,
             "extensions": kwargs.get("extensions", []),
@@ -23,11 +31,11 @@ class HTMXJSExtension(InclusionTagExtension):
 class HTMXFragmentExtension(Extension):
     tags = {"htmxfragment"}
 
-    def __init__(self, environment):
+    def __init__(self, environment: jinja2.Environment):
         super().__init__(environment)
         environment.extend(htmx_fragment_nodes={})
 
-    def parse(self, parser):
+    def parse(self, parser: Parser) -> Node:
         lineno = next(parser.stream).lineno
 
         fragment_name = parser.parse_expression()
@@ -42,25 +50,27 @@ class HTMXFragmentExtension(Extension):
                 value = parser.parse_expression()
                 kwargs.append(nodes.Keyword(key, value))
 
-        body = parser.parse_statements(["name:endhtmxfragment"], drop_needle=True)
+        body = parser.parse_statements(("name:endhtmxfragment",), drop_needle=True)
 
         call = self.call_method(
             "_render_htmx_fragment",
-            args=[fragment_name, jinja2.nodes.ContextReference()],
+            args=[fragment_name, nodes.ContextReference()],
             kwargs=kwargs,
         )
 
-        node = jinja2.nodes.CallBlock(call, [], [], body).set_lineno(lineno)
+        node = CallBlock(call, [], [], body).set_lineno(lineno)
 
         # Store a reference to the node for later
-        self.environment.htmx_fragment_nodes.setdefault(parser.name, {})[
-            fragment_name.value
+        self.environment.htmx_fragment_nodes.setdefault(parser.name, {})[  # type: ignore[attr-defined]
+            fragment_name.value  # type: ignore[attr-defined]
         ] = node
 
         return node
 
-    def _render_htmx_fragment(self, fragment_name, context, caller, **kwargs):
-        def attrs_to_str(attrs):
+    def _render_htmx_fragment(
+        self, fragment_name: str, context: dict[str, Any], caller: Any, **kwargs: Any
+    ) -> str:
+        def attrs_to_str(attrs: dict[str, Any]) -> str:
             parts = []
             for k, v in attrs.items():
                 if v == "":
@@ -96,41 +106,46 @@ class HTMXFragmentExtension(Extension):
             return f'<{as_element} plain-hx-fragment="{fragment_name}" {attrs_str}>{caller()}</{as_element}>'
 
 
-def render_template_fragment(*, template, fragment_name, context):
+def render_template_fragment(
+    *, template: jinja2.Template, fragment_name: str, context: dict[str, Any]
+) -> str:
     template = find_template_fragment(template, fragment_name)
     return template.render(context)
 
 
-def find_template_fragment(template: jinja2.Template, fragment_name: str):
+def find_template_fragment(
+    template: jinja2.Template, fragment_name: str
+) -> jinja2.Template:
     # Look in this template for the fragment
-    callblock_node = template.environment.htmx_fragment_nodes.get(
+    callblock_node = template.environment.htmx_fragment_nodes.get(  # type: ignore[attr-defined]
         template.name, {}
     ).get(fragment_name)
 
     if not callblock_node:
         # Look in other templates for this fragment
         matching_callblock_nodes = []
-        for fragments in template.environment.htmx_fragment_nodes.values():
+        for fragments in template.environment.htmx_fragment_nodes.values():  # type: ignore[attr-defined]
             if fragment_name in fragments:
                 matching_callblock_nodes.append(fragments[fragment_name])
 
         if len(matching_callblock_nodes) == 0:
             # If we still haven't found anything, it's possible that we're
             # in a different/new worker/process and haven't parsed the related templates yet
-            ast = template.environment.parse(
-                template.environment.loader.get_source(
-                    template.environment, template.name
-                )[0]
-            )
-            for ref in meta.find_referenced_templates(ast):
-                if ref not in template.environment.htmx_fragment_nodes:
-                    # Trigger them to parse
-                    template.environment.get_template(ref)
-
-            # Now look again
-            for fragments in template.environment.htmx_fragment_nodes.values():
-                if fragment_name in fragments:
-                    matching_callblock_nodes.append(fragments[fragment_name])
+            if template.environment.loader and template.name:
+                ast = template.environment.parse(
+                    template.environment.loader.get_source(
+                        template.environment, template.name
+                    )[0]
+                )
+                for ref in meta.find_referenced_templates(ast):
+                    if ref not in template.environment.htmx_fragment_nodes:  # type: ignore[attr-defined]
+                        # Trigger them to parse
+                        template.environment.get_template(ref)
+
+                # Now look again
+                for fragments in template.environment.htmx_fragment_nodes.values():  # type: ignore[attr-defined]
+                    if fragment_name in fragments:
+                        matching_callblock_nodes.append(fragments[fragment_name])
 
         if len(matching_callblock_nodes) == 1:
             callblock_node = matching_callblock_nodes[0]
@@ -149,5 +164,5 @@ def find_template_fragment(template: jinja2.Template, fragment_name: str):
         )
 
     # Create a new template from the node
-    template_node = jinja2.nodes.Template(callblock_node.body)
-    return template.environment.from_string(template_node)
+    template_node = nodes.Template(callblock_node.body)  # type: ignore[attr-defined]
+    return template.environment.from_string(template_node)  # type: ignore[arg-type]

{plain_htmx-0.10.2 → plain_htmx-0.10.3}/plain/htmx/views.py

@@ -1,10 +1,16 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from plain.http import Response
 from plain.utils.cache import patch_vary_headers
 
 from .templates import render_template_fragment
 
 
 class HTMXViewMixin:
-    def render_template(self):
+    def render_template(self) -> str:
         template = self.get_template()
         context = self.get_template_context()
 
@@ -17,7 +23,7 @@ class HTMXViewMixin:
 
         return template.render(context)
 
-    def get_response(self):
+    def get_response(self) -> Response:
         response = super().get_response()
         # Tell browser caching to also consider the fragment header,
         # not just the url/cookie.
@@ -26,7 +32,7 @@ class HTMXViewMixin:
         )
         return response
 
-    def get_request_handler(self):
+    def get_request_handler(self) -> Callable[..., Any]:
         if self.is_htmx_request():
             # You can use an htmx_{method} method on views
             # (or htmx_{method}_{action} for specific actions)
@@ -45,12 +51,12 @@ class HTMXViewMixin:
 
         return super().get_request_handler()
 
-    def is_htmx_request(self):
+    def is_htmx_request(self) -> bool:
         return self.request.headers.get("HX-Request") == "true"
 
-    def get_htmx_fragment_name(self):
+    def get_htmx_fragment_name(self) -> str:
         # A custom header that we pass with the {% htmxfragment %} tag
         return self.request.headers.get("Plain-HX-Fragment", "")
 
-    def get_htmx_action_name(self):
+    def get_htmx_action_name(self) -> str:
         return self.request.headers.get("Plain-HX-Action", "")

{plain_htmx-0.10.2 → plain_htmx-0.10.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plain.htmx"
-version = "0.10.2"
+version = "0.10.3"
 description = "Integrate HTMX with templates and views."
 authors = [{name = "Dave Gaeddert", email = "dave.gaeddert@dropseed.dev"}]
 license = "BSD-3-Clause"