djxi 0.1.2__py3-none-any.whl

djxi/actions/__init__.py

@@ -0,0 +1,4 @@
+from .base import DxActionRouter
+from .router import dx_route
+
+__all__ = ["DxActionRouter", "dx_route"]

djxi/actions/base.py

@@ -0,0 +1,25 @@
+from django.http import HttpResponse
+from django.template import Template, RequestContext
+
+from .router import DXRouterMixin
+from .section import DXSectionTemplateMixin
+
+
+class DxActionRouter(DXSectionTemplateMixin, DXRouterMixin):
+    """Unify the Main User Loop into one class with defined routed actions and a section library.
+    Main User Loop = Request->Route->Logic->Render->Response ...
+
+    1) define the section template:
+        a) inline_template = <dx-section name="identifier"> html for this section </dx-section>
+        b) template_name = path/to/template.html (app/template.html)
+    2) set up actions as class methods with the route decorator
+    3) hook the router into a url conf
+    """
+
+    def render_section(self, request, section_name, context=None):
+        """Render a dx-section as a full HTTP response."""
+        if context is None:
+            context = {}
+        raw_html = self.get_section(section_name)
+        template = Template(raw_html)
+        return HttpResponse(template.render(RequestContext(request, context)))

djxi/actions/parser.py

@@ -0,0 +1,75 @@
+import os
+from html.parser import HTMLParser
+from django.template import loader
+
+from djxi.conf import package_settings as djxi_settings
+
+
+class SectionParser(HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self.section_tag = getattr(djxi_settings, "DX_SECTION_TAG", None)
+        self.sections = {}  # name -> inner HTML
+        self._current_name = None
+        self._inside = False
+        self._chunks = []
+
+    def handle_starttag(self, tag, attrs):
+        if tag == self.section_tag:
+            # Extract the 'name' attribute
+            attrs_dict = dict(attrs)
+            name = attrs_dict.get("name")
+            if name:
+                self._current_name = name
+                self._inside = True
+                self._chunks = []
+            return
+        if self._inside:
+            # Re‑emit the opening tag (including its attributes)
+            attrs_str = " " + " ".join(f'{k}="{v}"' for k, v in attrs) if attrs else ""
+            self._chunks.append(f"<{tag}{attrs_str}>")
+
+    def handle_endtag(self, tag):
+        if tag == self.section_tag and self._inside:
+            # End of section – store the collected inner HTML
+            self.sections[self._current_name] = "".join(self._chunks)
+            self._inside = False
+            self._current_name = None
+            self._chunks = []
+        elif self._inside:
+            # Re‑emit the closing tag for nested elements
+            self._chunks.append(f"</{tag}>")
+
+    def handle_data(self, data):
+        if self._inside:
+            self._chunks.append(data)
+
+    def handle_startendtag(self, tag, attrs):
+        # Self‑closing tags (like <br/> or <img ... />)
+        if self._inside:
+            attrs_str = " " + " ".join(f'{k}="{v}"' for k, v in attrs) if attrs else ""
+            self._chunks.append(f"<{tag}{attrs_str}/>")
+
+
+def load_django_template(template_name: str) -> str:
+    """Loads a Django template from the given name."""
+    template_string = ""
+    # If template_name references a filesystem path, read it directly.
+    # In that case template name has to be an absolute path (this is mainly for the test suite)
+    if os.path.exists(template_name):
+        with open(template_name, "r", encoding="utf-8") as f:
+            template_string = f.read()
+    else:
+        # Attempt to load via Django's template loader (e.g. app/template.html).
+        try:
+            tpl = loader.get_template(template_name)
+            origin = getattr(tpl, "origin", None)
+            if origin and hasattr(origin, "loader"):
+                template_string = origin.loader.get_contents(origin)
+            else:
+                template_string = (
+                    getattr(getattr(tpl, "template", None), "source", "") or ""
+                )
+        except Exception:
+            template_string = ""
+    return template_string

djxi/actions/router.py

@@ -0,0 +1,103 @@
+""" Djxi Routing
+
+TODO: Potential Refactor
+- dx_route -> make_route | dx_mark_view
+- dx_router -> dx_collect_paths
+"""
+from functools import wraps
+from django.http import HttpResponseNotAllowed
+from django.urls import path
+
+
+class DXRouterMixin:
+    """Use as a Mixin to call CLS.dx_router() to get a list of djxi routes"""
+
+    @classmethod
+    def dx_router(cls) -> list:
+        """
+        Generate a list of Django URL patterns from all methods decorated with @route.
+        Use the class method to DxActionRouter.dx_router() in the url conf to hook the routes
+        """
+        patterns = []
+
+        for attr_name in dir(cls):
+            attr = getattr(cls, attr_name)
+            if hasattr(attr, "_routes"):
+                for url_path, methods, name in attr._routes:
+                    # Create a view that instantiates the class and calls the method
+                    def make_view(method_name, allowed_methods, attr_func=attr):
+                        @wraps(attr_func)
+                        def view(request, *args, **kwargs):
+                            if request.method not in allowed_methods:
+                                return HttpResponseNotAllowed(allowed_methods)
+                            instance = cls()  # instantiate the view class
+                            handler = getattr(instance, method_name)
+                            return handler(request, *args, **kwargs)
+
+                        return view
+
+                    patterns.append(
+                        path(url_path, make_view(attr_name, methods), name=name)
+                    )
+
+        return patterns
+
+
+def dx_route(path: str, methods: [] = None, **kwargs):
+    """
+    Decorator to mark a class method as a URL endpoint.
+    - path: URL path (can include Django path converters, e.g. '/items/<int:id>/')
+    - methods: list of allowed HTTP methods (defaults to ["GET"])
+    - kwargs:
+        - name: qualify the route with a name, default to func.__name__
+    """
+    if methods is None:
+        methods = ["GET"]
+
+    def decorator(func):
+        name = kwargs.pop("name", func.__name__)
+        if not hasattr(func, "_routes"):
+            func._routes = []
+        func._routes.append((path, methods, name))
+        return func
+
+    return decorator
+
+
+#
+# Alias definitions
+#
+def dx_GET(path: str, **kwargs):
+    return dx_route(path, ["GET"], **kwargs)
+
+
+def dx_HEAD(path: str, **kwargs):
+    return dx_route(path, ["HEAD"], **kwargs)
+
+
+def dx_POST(path: str, **kwargs):
+    return dx_route(path, ["POST"], **kwargs)
+
+
+def dx_PUT(path: str, **kwargs):
+    return dx_route(path, ["PUT"], **kwargs)
+
+
+def dx_PATCH(path: str, **kwargs):
+    return dx_route(path, ["PATCH"], **kwargs)
+
+
+def dx_DELETE(path: str, **kwargs):
+    return dx_route(path, ["DELETE"], **kwargs)
+
+
+def dx_OPTIONS(path: str, **kwargs):
+    return dx_route(path, ["OPTIONS"], **kwargs)
+
+
+def dx_ANY(path: str, **kwargs):
+    return dx_route(
+        path,
+        ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
+        **kwargs,
+    )

djxi/actions/section.py

@@ -0,0 +1,49 @@
+from django.core.exceptions import ImproperlyConfigured
+
+from .parser import SectionParser, load_django_template
+
+
+class DXSectionTemplateMixin:
+    """"""
+
+    section_inline = None
+    section_template_name = None
+
+    def __init__(self, **kwargs):
+        """Constructor builds the dx section cache."""
+        if self.section_inline is None and self.section_template_name is None:
+            raise ImproperlyConfigured(
+                "DxActionRouter requires a definition of sections via "
+                "'section_inline' or a path to a 'section_template_name'"
+            )
+        self.build_section_cache()
+
+    def build_section_cache(self) -> None:
+        """On init builds the section cache.
+        A dictionary with the (k,v) = name-of-section, html_string.
+        """
+        self._dx_section_cache = self.parse_section_dict()
+
+    def parse_section_dict(self) -> dict:
+        """Parses the string and extract the dx-section parts."""
+        parser = SectionParser()
+        parser.feed(self.build_section_string())
+        return parser.sections
+
+    def build_section_string(self) -> str:
+        """Concatenates the specified templates and returns the unmodified string.
+        In most cases you want to set one or the other, yet both is allowed.
+        Sections are read in order and later redefinition may override.
+        """
+        section_string = ""
+        if self.section_template_name is not None:
+            section_string = load_django_template(self.section_template_name)
+        if self.section_inline is not None:
+            section_string += self.section_inline
+        return section_string
+
+    def get_section(self, name: str) -> str:
+        """Returns the djxi section from the _dx_section_cache.
+        If name cannot be found, returns empty string.
+        """
+        return self._dx_section_cache.get(name, "")

djxi/apps.py

@@ -0,0 +1,27 @@
+from django.apps import AppConfig
+from django.core.exceptions import ImproperlyConfigured
+
+
+class DjxiAppConfig(AppConfig):
+    name = "djxi"
+    verbose_name = "Djxi"
+
+    def ready(self):
+        """
+        Django calls this method when the application registry is fully loaded.
+        This is the safest place to import signals, validators, or run
+        one-time startup code.
+        """
+        # Validate required settings exist and sane
+        from .conf import package_settings
+
+        htmx_version = package_settings.DX_HTMX_VERSION
+        if htmx_version not in ["2", "4"]:
+            raise ImproperlyConfigured("DX_HTMX_VERSION must be 2 or 4")
+
+        section_tag = package_settings.DX_SECTION_TAG
+        if section_tag in ["", None]:
+            raise ImproperlyConfigured("DX_SECTION_TAG can not be None or empty")
+
+        # Optional: Import signals if you have a signals.py file
+        # import mypackage.signals

djxi/conf.py

@@ -0,0 +1,27 @@
+from django.conf import settings
+
+# Define your package's default settings here.
+# Use ALL CAPS names, just like Django's own settings.
+DEFAULTS = {
+    "DX_HTMX_VERSION": "4",
+    "DX_HTMX_MINIFIED": True,
+    "DX_SECTION_TAG": "dx-section",
+}
+
+
+class Settings:
+    """
+    A proxy object that reads from django.conf.settings first,
+    and falls back to DEFAULTS if the user didn't define it.
+    """
+
+    def __getattr__(self, name):
+        if name not in DEFAULTS:
+            raise AttributeError(f"Invalid setting: '{name}'")
+
+        # Return the user's value from settings.py, or fall back to the default
+        return getattr(settings, name, DEFAULTS[name])
+
+
+# Instantiate a single global object for easy import
+package_settings = Settings()

djxi/templates/htmx_headers.html

@@ -0,0 +1 @@
+hx-headers{% if explicit_inheritance %}:inherited{% endif %}='{"X-CSRFTOKEN":"{{ csrf_token }}"}'

djxi/templates/htmx_script.html

@@ -0,0 +1,5 @@
+{% if version is "2" %}
+    <script src="https://cdn.jsdelivr.net/npm/htmx.org@2.0.10/dist/htmx{{minified}}.js" integrity="sha384-H5SrcfygHmAuTDZphMHqBJLc3FhssKjG7w/CeCpFReSfwBWDTKpkzPP8c+cLsK+V" crossorigin="anonymous"></script>
+{% else %}
+    <script src="https://cdn.jsdelivr.net/npm/htmx.org@4.0.0-beta5/dist/htmx{{minified}}.js" integrity="sha384-RZoQSZlu2BAuZMuM5lTKAWXXSKC+7X6eVzP1pwkUBcyfPmOswexqVOsUqQMKbAFA" crossorigin="anonymous"></script>
+{% endif %}

djxi/templatetags/djxi.py

@@ -0,0 +1,16 @@
+from django.template import Library
+from djxi.conf import package_settings as djxi_settings
+
+register = Library()
+
+
+@register.inclusion_tag("htmx_script.html")
+def htmx_script_inclusion():
+    minified = ".min" if djxi_settings.DX_HTMX_MINIFIED is True else ""
+    return {"version": djxi_settings.DX_HTMX_VERSION, "minified": minified}
+
+
+@register.inclusion_tag("htmx_headers.html")
+def htmx_headers():
+    explicit_inheritance = djxi_settings.DX_HTMX_VERSION == "4"
+    return {"explicit_inheritance": explicit_inheritance}

djxi-0.1.2.dist-info/METADATA

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: djxi
+Version: 0.1.2
+Summary: Django HTMX Integration
+Author-email: Philipp Rollinger <philipp.rollinger@protonmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/rollinger/djxi
+Project-URL: Repository, https://github.com/rollinger/djxi
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENCE.md
+Requires-Dist: django>=4.2
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: ruff>=0.0.275; extra == "dev"
+Requires-Dist: pre-commit>=3.0; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Dynamic: license-file
+
+# Djxi | **HTMX Integration for Django** 
+![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit)
+---
+[![CI](https://github.com/rollinger/djxi/actions/workflows/main.yml/badge.svg)](https://github.com/rollinger/djxi/actions/workflows/main.yml)
+[![codecov](https://codecov.io/gh/rollinger/djxi/branch/master/graph/badge.svg)](https://codecov.io/gh/rollinger/djxi)
+[![PyPI](https://img.shields.io/pypi/v/djxi)](https://pypi.org/project/djxi)
+[![PyPI - Wheel](https://img.shields.io/pypi/wheel/djxi)](https://pypi.org/project/djxi)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/djxi)](https://pypi.org/project/djxi)
+---
+
+## 📦 What is this?
+
+**Stop hunting for HTMX endpoints.**  
+Djxi bundles the route, the view logic, and the HTML partial into a single **Endpoint Battery**. 
+Drop the `DxActionRouter` into your existing Django views or use it standalone. Keep every tiny `hx-*` swap exactly where it lives—without scattering your code across `urls.py`, `views/`, and `templates/`.
+
+- **No more archaeology.** No more digging through three files just to tweak a button label.  
+- **LoB, restored.** Request → Logic → Render stays in one atomic, inline hub.  
+- **Scales cleanly.** Small partials stay manageable, without turning your project into spaghetti.
+
+Just a prenup between Grandpa Django and his sexy new HTMX fling—keeping your repo clean, one battery at a time.
+
+## Pre-Alpha Note
+The package is not yet published and considered in experimental pre-alpha state.
+- Watch out for updates and consider giving it a star.
+- Checkout the djxi showcases in the example django app.
+
+---
+
+## Getting Started
+### Instalation
+1) Install with pip:
+
+`python -m pip install djxi`
+
+2) Add django-htmx to your INSTALLED_APPS:
+
+```python
+INSTALLED_APPS = [
+    ...,
+    "djxi",
+    ...,
+]
+```
+
+3) Optional: Adjust your base template to get you up and running instantly
+```html
+ {% load djxi %}
+ <!doctype html>
+ <html>
+   <head>
+     ...
+     {% htmx_script_inclusion %}
+   </head>
+   <body {% htmx_headers %}>
+     ...
+   </body>
+ </html>
+```
+The htmx_script_inclusion tag will pull the unminified v4 from CDN. Set DX_HTMX_VERSION="2" to pull in v2.
+For prodution you likely want to serve your own minified htmx.js.
+
+As there are significant syntax changes between v4 and v2 of htmx, keep DX_HTMX_VERSION in sync with 
+what htmx version you are serving.
+
+### Configuration
+In your settings file you can overide the following default values for Djxi:
+- DX_HTMX_VERSION": "4" # Choose between 4 and 2
+- DX_HTMX_MINIFIED": False # Load a minified source, recommended for production
+
+### Quick start
+Create and manage your HTMX Endpoint in a convenient Battery:
+
+```python
+from djxi.actions import DxActionRouter, dx_route
+
+INLINE_TEMPLATE = """
+<dx-section name="confirm-button">
+    <button hx-post="/showcase/simple/confirm">
+        Confirm, {{ name }}
+    </button>
+</dx-section>
+
+<dx-section name="check-confirmed">
+    <button disabled>Confirmed!</button>
+</dx-section>
+"""
+
+class SimpleInlineActionRouter(DxActionRouter):
+    inline_template = INLINE_TEMPLATE
+    
+    @dx_route("get-confirm-button", methods=["GET"])
+    def get_confirm_button(self, request):
+        context = {"name": "Phil"}
+        return self.render_section(
+            request, section_name="confirm-button", context=context
+        )
+```

djxi-0.1.2.dist-info/RECORD

@@ -0,0 +1,24 @@
+djxi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+djxi/apps.py,sha256=VkuR7GCtN4bil6bdwnPQ0fnvKUH55AYDVMIEU7AbxGA,940
+djxi/conf.py,sha256=pnfM8dBbpNUDjaXVy3CTEaY3UXKmun68nr4v7LUnqQc,754
+djxi/actions/__init__.py,sha256=bGieYBqGmiM9TO4osylRgh0sXHHEWFoexwvozERyRJU,104
+djxi/actions/base.py,sha256=FT7w7d3uk7X2zEDa0O5ZPfMEniG0sHueGwA2v6P4JD0,1055
+djxi/actions/parser.py,sha256=sA6OlnE8snJmBw_rsVYpgDHPUMh_iA__r4iOYdhUa_8,2858
+djxi/actions/router.py,sha256=YmWwcdLPChO4CkuUnXjCaVd0dsZdnnCOVCJD71pzUwU,3038
+djxi/actions/section.py,sha256=RxB4-Lw1x3PRLPjGkhUUAtNq1LcASBkCmb_rrRr3aIs,1868
+djxi/templates/htmx_headers.html,sha256=8I9e-IHH3dMyJ3unUxeYLP3lLeeKZDSBDcPX5K1E4Do,97
+djxi/templates/htmx_script.html,sha256=tK9yc1IkV3HJXcYXNT0qq37wqqHAxp5wFUre9zqISgI,463
+djxi/templatetags/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+djxi/templatetags/djxi.py,sha256=e9zEWu68kQ4kd3ydvArZEYm9baRZuj7jTVeemU65FJk,526
+djxi-0.1.2.dist-info/licenses/LICENCE.md,sha256=No1vF19rSru7Liq0pzUzfWaFLl0R0bd7D3aprQ6T9_M,1073
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/conftest.py,sha256=5KrxJ2VyLp8TMcw1pf-QUFnrcmsH2Mkxi1eEKw_zQ2Y,983
+tests/test_actions.py,sha256=ltPcR9A9kOwXQ1IUSQb6IbnKoIlI79jfS1qIYj-0VtQ,1541
+tests/test_parser.py,sha256=zr_6OQU3THLdUyu32kaVrguUrtgs35kny53-NOe3xMI,1237
+tests/test_routing.py,sha256=Q1jD9M859Uz92XKo3hVx82FsWf5cGyuwLcvZ_L3NCXE,3185
+tests/test_settings.py,sha256=nsQSFqVTuy8NJ7yE22tcKKBM46WxeL3wO04T2kLlPm4,678
+tests/test_template_compat.py,sha256=TwFKVqzuc1do21CxsO3X64YhVl2EtdqWhPnsXXbBxnE,4477
+djxi-0.1.2.dist-info/METADATA,sha256=EOBndSD_ItbBC5rt2iZcbgDRL3HU1vyjZzDVKuHFZUU,4083
+djxi-0.1.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+djxi-0.1.2.dist-info/top_level.txt,sha256=iPqRhXpD7kKW5S5T7CoZaYG-WkV68sVourW1aSdd5gk,11
+djxi-0.1.2.dist-info/RECORD,,

djxi-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

djxi-0.1.2.dist-info/licenses/LICENCE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Philipp Rollinger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

djxi-0.1.2.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+djxi
+tests

tests/conftest.py

@@ -0,0 +1,32 @@
+import django
+from pathlib import Path
+from django.conf import settings
+
+TEST_DIR = Path(__file__).parent
+TEMPLATE_DIR = str(TEST_DIR / "data")  # absolute string path usable by Django
+
+# Configure Django only once
+if not settings.configured:
+    settings.configure(
+        SECRET_KEY="dummy-secret-for-testing",
+        ROOT_URLCONF=__name__,  # will be overridden per test if needed
+        INSTALLED_APPS=[
+            "django.contrib.auth",
+            "django.contrib.contenttypes",
+            "djxi",
+        ],
+        MIDDLEWARE=[],  # empty for speed
+        TEMPLATES=[
+            {
+                "BACKEND": "django.template.backends.django.DjangoTemplates",
+                "DIRS": [TEMPLATE_DIR],
+                "APP_DIRS": True,
+                "OPTIONS": {
+                    "context_processors": [
+                        "django.template.context_processors.request",
+                    ],
+                },
+            }
+        ],
+    )
+    django.setup()

tests/test_actions.py

@@ -0,0 +1,50 @@
+import pytest
+from django.core.exceptions import ImproperlyConfigured
+
+from djxi.actions import DxActionRouter
+
+INLINE_TEMPLATE = """
+<dx-section name="a-b">AB</dx-section><dx-section name="long spaced name">
+Long spaced Name
+</dx-section>
+
+<dx-section name="b-c-d">
+    This should be good<br>
+</dx-section>
+"""
+
+
+class EmptyActionRouter(DxActionRouter):
+    pass
+
+
+class InlineActionRouter(DxActionRouter):
+    section_inline = INLINE_TEMPLATE
+
+
+class TemplateActionRouter(DxActionRouter):
+    section_template_name = "template.html"
+
+
+def test_djxi_empty_init():
+    # Raise error if inline_template and template_name is not configured
+    with pytest.raises(ImproperlyConfigured):
+        dx_action = EmptyActionRouter()  # noqa: F841
+
+
+def test_djxi_inline_build_sections():
+    dx_action = InlineActionRouter()
+    assert len(dx_action._dx_section_cache) == 3
+    assert dx_action.get_section("a-b") == "AB"
+    assert dx_action.get_section("long spaced name") == "\nLong spaced Name\n"
+    assert dx_action.get_section("b-c-d") == "\n    This should be good<br>\n"
+    assert dx_action.get_section("this-key-does-not_exist") == ""
+
+
+def test_djxi_template_build_sections():
+    dx_action = TemplateActionRouter()
+    assert len(dx_action._dx_section_cache) == 3
+    assert dx_action.get_section("a-b") == "AB"
+    assert dx_action.get_section("long spaced name") == "\nLong spaced Name\n"
+    assert dx_action.get_section("b-c-d") == "\n    This should be good<br>\n"
+    assert dx_action.get_section("this-key-does-not_exist") == ""

tests/test_parser.py

@@ -0,0 +1,38 @@
+from django.test import override_settings
+
+from djxi.actions import DxActionRouter
+
+DEFAULT = "dx-section"
+CUSTOM = "my-section-tag"
+
+INLINE_TEMPLATE = f"""
+<unrelated-tag>
+<{DEFAULT} name="section_01">Content 1</{DEFAULT}>
+<{DEFAULT} name="section_02">Content 2</{DEFAULT}>
+<unrelated-tag/ >
+<{CUSTOM} name="section_03">Content 3</{CUSTOM}>
+<{DEFAULT} name="section_04">Content 4</{DEFAULT}>
+<unrelated-tag>XYZ</unrelated-tag>
+<{CUSTOM} name="section_05">Content 5</{CUSTOM}>
+"""
+
+
+class InlineActionRouter(DxActionRouter):
+    section_inline = INLINE_TEMPLATE
+
+
+@override_settings(DX_SECTION_TAG=DEFAULT)
+def test_default_section_tag():
+    default_router = InlineActionRouter()
+    assert len(default_router._dx_section_cache) == 3
+    assert default_router.get_section("section_01") == "Content 1"
+    assert default_router.get_section("section_02") == "Content 2"
+    assert default_router.get_section("section_04") == "Content 4"
+
+
+@override_settings(DX_SECTION_TAG=CUSTOM)
+def test_custom_section_tag():
+    custom_router = InlineActionRouter()
+    assert len(custom_router._dx_section_cache) == 2
+    assert custom_router.get_section("section_03") == "Content 3"
+    assert custom_router.get_section("section_05") == "Content 5"

tests/test_routing.py

@@ -0,0 +1,83 @@
+# fmt: off
+from django.test import override_settings, RequestFactory
+from django.urls import path, include, resolve, reverse
+
+from djxi.actions import DxActionRouter, dx_route
+
+INLINE_TEMPLATE = """
+<dx-section name="section_01">Content 1</dx-section>
+<dx-section name="section_02">Content 2</dx-section>
+<dx-section name="section_03">Content 3</dx-section>
+"""
+
+
+class InlineActionRouter(DxActionRouter):
+    section_inline = INLINE_TEMPLATE
+
+    @dx_route("section/1", methods=["GET"], name="nifty_first_section")
+    def section_01(self, request):
+        return self.render_section(request, "section_01")
+
+    @dx_route("section/2/", methods=["GET"])
+    def section_02(self, request):
+        return self.render_section(request, "section_02")
+
+    @dx_route("section/3", methods=["GET", "POST"])
+    def section_03(self, request):
+        return self.render_section(request, "section_03")
+
+    @dx_route("section/<int:id>", methods=["GET"], name="get_the_section_you_want")
+    def section_by_id(self, request, id):
+        section_name = f"section_{id}"
+        return self.render_section(request, section_name)
+
+
+# URL Patterns from .dx_router
+urlpatterns = [
+    path("", include((InlineActionRouter.dx_router(), "djxi"), namespace="djxi"))
+]
+
+
+@override_settings(ROOT_URLCONF=__name__)
+def test_path_resolver():
+    true_paths = {
+        "/section/1": {"view": "section_01", "args": (), "kwargs": {}, "content": "Content 1"},
+        "/section/2/": {"view": "section_02", "args": (), "kwargs": {}, "content": "Content 2"},
+        "/section/3": {"view": "section_03", "args": (), "kwargs": {}, "content": "Content 3"},
+        "/section/4": {"view": "section_by_id", "args": (), "kwargs": {"id": 4}, "content": ""},
+        "/section/99": {"view": "section_by_id", "args": (), "kwargs": {"id": 99}, "content": ""},
+    }
+    rf = RequestFactory()
+    for request_path, truth in true_paths.items():
+        match = resolve(request_path)
+        assert match.func.__name__ == truth["view"]
+        assert match.args == truth["args"]
+        assert match.kwargs == truth["kwargs"]
+        req = rf.get(request_path)
+        assert match.func(req, *match.args, **match.kwargs).content.decode() == truth["content"]
+
+@override_settings(ROOT_URLCONF=__name__)
+def test_name_resolver():
+    request_path = reverse("djxi:nifty_first_section")
+    assert request_path == "/section/1"
+    match = resolve(request_path)
+    assert match.func.__name__ == "section_01"
+
+
+@override_settings(ROOT_URLCONF=__name__)
+def test_no_name_resolver():
+    request_path = reverse("djxi:section_02")
+    assert request_path == "/section/2/"
+    match = resolve(request_path)
+    assert match.func.__name__ == "section_02"
+
+@override_settings(ROOT_URLCONF=__name__)
+def test_name_override_resolver():
+    request_path = reverse("djxi:get_the_section_you_want", kwargs={"id": 3})
+    assert request_path == "/section/3"
+    match = resolve(request_path)
+    assert match.func.__name__ == "section_03"
+    request_path = reverse("djxi:get_the_section_you_want", kwargs={"id": 4})
+    assert request_path == "/section/4"
+    match = resolve(request_path)
+    assert match.func.__name__ == "section_by_id"

tests/test_settings.py

@@ -0,0 +1,19 @@
+from django.test import override_settings
+
+from djxi.conf import package_settings as djxi_settings
+
+
+def test_conf_DX_HTMX_VERSION():
+    assert djxi_settings.DX_HTMX_VERSION == "4"
+    with override_settings(DX_HTMX_VERSION="2"):
+        assert djxi_settings.DX_HTMX_VERSION == "2"
+
+
+def test_conf_DX_SECTION_TAG():
+    section_name = getattr(djxi_settings, "DX_SECTION_TAG", None)
+    assert section_name is not None
+    assert section_name == "dx-section"
+    with override_settings(DX_SECTION_TAG="my-section-tag"):
+        section_name = getattr(djxi_settings, "DX_SECTION_TAG", None)
+        assert section_name is not None
+        assert section_name == "my-section-tag"

tests/test_template_compat.py

@@ -0,0 +1,119 @@
+""" Test compatibility of inline sections with Django Templating Tags and Filter"""
+from django.test import override_settings, RequestFactory, modify_settings
+from django.urls import path, include, resolve, reverse
+
+from djxi.actions import DxActionRouter, dx_route
+
+INLINE_TEMPLATE = """
+<dx-section name="hello-world">
+    <p>Hello, {{ name }}!</p>
+</dx-section>
+<dx-section name="hello-many">
+    <p>Hello {% for name in names %}{{ name }}{% if not forloop.last %}, {% endif %}{% endfor %}!</p>
+</dx-section>
+<dx-section name="hello-filter">
+    <p>{{ number|floatformat:3 }}</p>
+</dx-section>
+<dx-section name="hello-humanize">
+    {% load humanize %}
+    <p>{{ number|intword }}</p>
+</dx-section>
+<dx-section name="hello-include">
+    <p>Hello {% for name in names %}{% include "partial.html" %}{% endfor %}!</p>
+</dx-section>
+
+"""
+
+
+class InlineActionRouter(DxActionRouter):
+    section_inline = INLINE_TEMPLATE
+
+    @dx_route("hello/<str:name>", methods=["GET"], name="hello_world")
+    def hallo_du(self, request, name: str):
+        context = {"name": name}
+        return self.render_section(request, "hello-world", context)
+
+    @dx_route("hello-all", methods=["GET"], name="hello_many")
+    def hello_many(self, request):
+        context = {"names": ["Django", "World", "Python"]}
+        return self.render_section(request, "hello-many", context)
+
+    @dx_route("hello-filter/<str:number>", methods=["GET"])
+    def hello_filter(self, request, number: str):
+        context = {"number": number}
+        return self.render_section(request, "hello-filter", context)
+
+    @dx_route("hello-humanize/<str:number>", methods=["GET"])
+    def hello_humanize(self, request, number: str):
+        return self.render_section(request, "hello-humanize", {"number": number})
+
+    @dx_route("hello_include", methods=["GET"])
+    def hello_include(self, request):
+        context = {"names": ["Django", "World", "Python"]}
+        return self.render_section(request, "hello-include", context)
+
+
+# URL Patterns from .dx_router
+urlpatterns = [
+    path("", include((InlineActionRouter.dx_router(), "djxi"), namespace="djxi"))
+]
+
+
+@override_settings(ROOT_URLCONF=__name__)
+def test_value_interpolation():
+    rf = RequestFactory()
+    resolver_match = resolve(reverse("djxi:hello_world", kwargs={"name": "Django"}))
+    req = rf.get(resolver_match.url_name)
+    response = resolver_match.func(req, *resolver_match.args, **resolver_match.kwargs)
+    assert req.method == "GET"
+    assert response.status_code == 200
+    assert response.content.decode().strip() == "<p>Hello, Django!</p>"
+
+
+@override_settings(ROOT_URLCONF=__name__)
+def test_builtin_templatetags():
+    rf = RequestFactory()
+    resolver_match = resolve(reverse("djxi:hello_many"))
+    req = rf.get(resolver_match.url_name)
+    response = resolver_match.func(req, *resolver_match.args, **resolver_match.kwargs)
+    assert req.method == "GET"
+    assert response.status_code == 200
+    assert response.content.decode().strip() == "<p>Hello Django, World, Python!</p>"
+
+
+@override_settings(ROOT_URLCONF=__name__)
+def test_template_include():
+    rf = RequestFactory()
+    resolver_match = resolve(reverse("djxi:hello_include"))
+    req = rf.get(resolver_match.url_name)
+    response = resolver_match.func(req, *resolver_match.args, **resolver_match.kwargs)
+    assert req.method == "GET"
+    assert response.status_code == 200
+    assert response.content.decode().strip() == "<p>Hello Django & World & Python!</p>"
+
+
+@override_settings(ROOT_URLCONF=__name__)
+def test_buildin_filter():
+    rf = RequestFactory()
+    resolver_match = resolve(
+        reverse("djxi:hello_filter", kwargs={"number": "108.999212"})
+    )
+    req = rf.get(resolver_match.url_name)
+    response = resolver_match.func(req, *resolver_match.args, **resolver_match.kwargs)
+    assert req.method == "GET"
+    assert response.status_code == 200
+    assert response.content.decode().strip() == "<p>108.999</p>"
+
+
+@modify_settings(INSTALLED_APPS={"append": "django.contrib.humanize"})
+@override_settings(ROOT_URLCONF=__name__)
+def test_opt_in_tags():
+    rf = RequestFactory()
+    resolver_match = resolve(
+        reverse("djxi:hello_humanize", kwargs={"number": "1000000"})
+    )
+    req = rf.get(resolver_match.url_name)
+    response = resolver_match.func(req, *resolver_match.args, **resolver_match.kwargs)
+    assert req.method == "GET"
+    assert response.status_code == 200
+    assert response.content.decode().strip() == "<p>1.0 million</p>"