component_framework.adapters.django_renderer

Django template renderer implementation.

 1"""Django template renderer implementation."""
 2
 3try:
 4    from django.template import Context, Template
 5    from django.template.loader import render_to_string
 6    from django.utils.html import escape
 7except ImportError as e:
 8    from . import _require_extra
 9
10    raise _require_extra("django", "django") from e
11
12from ..core import Renderer
13
14
15class DjangoRenderer(Renderer):
16    """Renderer using Django template system."""
17
18    def __init__(self, use_cotton: bool = False):
19        """
20        Initialize Django renderer.
21
22        Args:
23            use_cotton: Whether to use django-cotton for component rendering
24        """
25        self.use_cotton = use_cotton
26
27    def render(self, template_name: str, context: dict) -> str:
28        """
29        Render Django template.
30
31        Args:
32            template_name: Template path (e.g., 'components/counter.html')
33            context: Template context variables
34
35        Returns:
36            Rendered HTML string
37        """
38        return render_to_string(template_name, context)
39
40
41class DjangoCottonRenderer(Renderer):
42    """Renderer using django-cotton components."""
43
44    def render(self, template_name: str, context: dict) -> str:
45        """
46        Render django-cotton component.
47
48        Args:
49            template_name: Cotton component name (e.g., 'counter')
50            context: Component props/context
51
52        Returns:
53            Rendered HTML string
54        """
55        # Cotton components are referenced with 'c-' prefix
56        # e.g., 'counter' becomes <c-counter ... />
57        # We use Django's template system to render the cotton component
58        cotton_template = f"{{% load cotton %}}<c-{template_name} {self._build_attrs(context)} />"
59        template = Template(cotton_template)
60        return template.render(Context(context))
61
62    def _build_attrs(self, context: dict) -> str:
63        """Build cotton component attributes from context.
64
65        Values are HTML-escaped to prevent XSS when context contains user input.
66        """
67        attrs = []
68        for key, value in context.items():
69            if isinstance(value, (str, int, float, bool)):
70                attrs.append(f'{escape(str(key))}="{escape(str(value))}"')
71            else:
72                # For complex objects, pass through context variable reference
73                attrs.append(f':{escape(str(key))}="{escape(str(key))}"')
74        return " ".join(attrs)
class DjangoRenderer(component_framework.core.renderer.Renderer): 
16class DjangoRenderer(Renderer):
17    """Renderer using Django template system."""
18
19    def __init__(self, use_cotton: bool = False):
20        """
21        Initialize Django renderer.
22
23        Args:
24            use_cotton: Whether to use django-cotton for component rendering
25        """
26        self.use_cotton = use_cotton
27
28    def render(self, template_name: str, context: dict) -> str:
29        """
30        Render Django template.
31
32        Args:
33            template_name: Template path (e.g., 'components/counter.html')
34            context: Template context variables
35
36        Returns:
37            Rendered HTML string
38        """
39        return render_to_string(template_name, context)

Renderer using Django template system.

DjangoRenderer(use_cotton: bool = False) 
19    def __init__(self, use_cotton: bool = False):
20        """
21        Initialize Django renderer.
22
23        Args:
24            use_cotton: Whether to use django-cotton for component rendering
25        """
26        self.use_cotton = use_cotton

Initialize Django renderer.

Arguments:
  • use_cotton: Whether to use django-cotton for component rendering
use_cotton
def render(self, template_name: str, context: dict) -> str: 
28    def render(self, template_name: str, context: dict) -> str:
29        """
30        Render Django template.
31
32        Args:
33            template_name: Template path (e.g., 'components/counter.html')
34            context: Template context variables
35
36        Returns:
37            Rendered HTML string
38        """
39        return render_to_string(template_name, context)

Render Django template.

Arguments:
  • template_name: Template path (e.g., 'components/counter.html')
  • context: Template context variables
Returns:

Rendered HTML string

class DjangoCottonRenderer(component_framework.core.renderer.Renderer): 
42class DjangoCottonRenderer(Renderer):
43    """Renderer using django-cotton components."""
44
45    def render(self, template_name: str, context: dict) -> str:
46        """
47        Render django-cotton component.
48
49        Args:
50            template_name: Cotton component name (e.g., 'counter')
51            context: Component props/context
52
53        Returns:
54            Rendered HTML string
55        """
56        # Cotton components are referenced with 'c-' prefix
57        # e.g., 'counter' becomes <c-counter ... />
58        # We use Django's template system to render the cotton component
59        cotton_template = f"{{% load cotton %}}<c-{template_name} {self._build_attrs(context)} />"
60        template = Template(cotton_template)
61        return template.render(Context(context))
62
63    def _build_attrs(self, context: dict) -> str:
64        """Build cotton component attributes from context.
65
66        Values are HTML-escaped to prevent XSS when context contains user input.
67        """
68        attrs = []
69        for key, value in context.items():
70            if isinstance(value, (str, int, float, bool)):
71                attrs.append(f'{escape(str(key))}="{escape(str(value))}"')
72            else:
73                # For complex objects, pass through context variable reference
74                attrs.append(f':{escape(str(key))}="{escape(str(key))}"')
75        return " ".join(attrs)

Renderer using django-cotton components.

def render(self, template_name: str, context: dict) -> str: 
45    def render(self, template_name: str, context: dict) -> str:
46        """
47        Render django-cotton component.
48
49        Args:
50            template_name: Cotton component name (e.g., 'counter')
51            context: Component props/context
52
53        Returns:
54            Rendered HTML string
55        """
56        # Cotton components are referenced with 'c-' prefix
57        # e.g., 'counter' becomes <c-counter ... />
58        # We use Django's template system to render the cotton component
59        cotton_template = f"{{% load cotton %}}<c-{template_name} {self._build_attrs(context)} />"
60        template = Template(cotton_template)
61        return template.render(Context(context))

Render django-cotton component.

Arguments:
  • template_name: Cotton component name (e.g., 'counter')
  • context: Component props/context
Returns:

Rendered HTML string