Examples & Demos.

 1from djust import LiveView, event_handler
 2
 3class CounterView(LiveView):
 4    template_name = 'counter.html'
 5
 6    def mount(self, request):
 7        """Initialize counter state"""
 8        self.count = 0
 9
10    @event_handler
11    def increment(self):
12        """Increment counter by 1"""
13        self.count += 1
14
15    @event_handler
16    def decrement(self):
17        """Decrement counter by 1"""
18        self.count -= 1
19
20    @event_handler
21    def reset(self):
22        """Reset counter to 0"""
23        self.count = 0
24
25    def get_context_data(self, **kwargs):
26        return {'count': self.count}

 1from djust import LiveView, event_handler
 2from djust.forms import FormMixin
 3from .forms import SignupForm
 4
 5class SignupView(FormMixin, LiveView):
 6    form_class = SignupForm
 7    template_name = 'signup.html'
 8
 9    def mount(self, request):
10        """Initialize form view"""
11        self.success_message = None
12
13    @event_handler
14    def validate_field(self, field: str = None, value: str = "", **kwargs):
15        """Real-time field validation"""
16        # Validation happens automatically via FormMixin
17        # Errors are displayed in real-time
18        pass
19
20    def form_valid(self, form):
21        """Handle valid form submission"""
22        # Save the user
23        user = form.save()
24        self.success_message = "Account created successfully!"
25        # Reset form
26        self.form = self.form_class()
27
28    def form_invalid(self, form):
29        """Handle invalid form submission"""
30        # Errors displayed automatically
31        pass

 1from djust import LiveView, event_handler
 2
 3class SearchView(LiveView):
 4    template_name = 'search.html'
 5
 6    USERS = [
 7        {"name": "Alice Johnson", "email": "alice@example.com", "role": "Admin"},
 8        {"name": "Bob Smith", "email": "bob@example.com", "role": "Editor"},
 9        {"name": "Carol White", "email": "carol@example.com", "role": "Viewer"},
10        {"name": "Dave Brown", "email": "dave@example.com", "role": "Editor"},
11        {"name": "Eve Davis", "email": "eve@example.com", "role": "Admin"},
12    ]
13
14    def mount(self, request):
15        self.query = ""
16        self.filtered_users = self.USERS
17
18    @event_handler
19    def search_users(self, value: str = "", **kwargs):
20        """Filter users by name or email"""
21        self.query = value
22        q = value.lower()
23        self.filtered_users = [
24            u for u in self.USERS
25            if q in u["name"].lower() or q in u["email"].lower()
26        ] if q else self.USERS
27
28    def get_context_data(self, **kwargs):
29        return {
30            'query': self.query,
31            'filtered_users': self.filtered_users,
32        }

 1from djust import LiveView, event_handler
 2
 3class KanbanView(LiveView):
 4    template_name = 'kanban.html'
 5
 6    def mount(self, request):
 7        self.columns = {
 8            'todo': [
 9                {'id': 1, 'text': 'Design homepage'},
10                {'id': 2, 'text': 'Write tests'},
11            ],
12            'doing': [
13                {'id': 3, 'text': 'Build API'},
14            ],
15            'done': [],
16        }
17        self.next_id = 4
18
19    @event_handler
20    def move_card(self, card_id: int = None,
21                  target: str = "", **kwargs):
22        """Move card to another column"""
23        for col, cards in self.columns.items():
24            card = next((c for c in cards if c['id'] == card_id), None)
25            if card:
26                cards.remove(card)
27                self.columns[target].append(card)
28                break
29
30    @event_handler
31    def add_card(self, column: str = "", text: str = "", **kwargs):
32        """Add new card to column"""
33        if text.strip():
34            self.columns[column].append({
35                'id': self.next_id, 'text': text
36            })
37            self.next_id += 1
38
39    def get_context_data(self, **kwargs):
40        return {'columns': self.columns}

 1from djust import LiveView, event_handler
 2
 3class WizardView(LiveView):
 4    template_name = 'wizard.html'
 5
 6    def mount(self, request):
 7        self.step = 1
 8        self.data = {'name': '', 'email': '', 'plan': ''}
 9        self.errors = {}
10        self.submitted = False
11
12    @event_handler
13    def wizard_next(self, **kwargs):
14        """Validate and advance to next step"""
15        if self.step == 1 and not kwargs.get('name', '').strip():
16            self.errors = {'name': 'Name is required'}
17            return
18        if self.step == 2 and '@' not in kwargs.get('email', ''):
19            self.errors = {'email': 'Valid email required'}
20            return
21        self.data.update(kwargs)
22        self.errors = {}
23        self.step += 1
24
25    @event_handler
26    def wizard_prev(self, **kwargs):
27        """Go back one step"""
28        if self.step > 1:
29            self.step -= 1
30
31    @event_handler
32    def wizard_submit(self, **kwargs):
33        """Submit the wizard form"""
34        self.data.update(kwargs)
35        self.submitted = True
36
37    def get_context_data(self, **kwargs):
38        return {
39            'step': self.step,
40            'wizard_data': self.data,
41            'wizard_errors': self.errors,
42            'submitted': self.submitted,
43        }

 1from djust import LiveView, event_handler
 2
 3class ConverterView(LiveView):
 4    template_name = 'converter.html'
 5
 6    def mount(self, request):
 7        self.celsius = 0
 8        self.fahrenheit = 32
 9
10    @event_handler
11    def update_celsius(self, value: str = "0", **kwargs):
12        try:
13            c = float(value)
14            self.celsius = c
15            self.fahrenheit = round(c * 9/5 + 32, 1)
16        except ValueError:
17            pass
18
19    @event_handler
20    def update_fahrenheit(self, value: str = "32", **kwargs):
21        try:
22            f = float(value)
23            self.fahrenheit = f
24            self.celsius = round((f - 32) * 5/9, 1)
25        except ValueError:
26            pass
27
28    def get_context_data(self, **kwargs):
29        return {
30            'celsius': self.celsius,
31            'fahrenheit': self.fahrenheit,
32        }

 1from djust import LiveView, event_handler
 2from djust.mixins import StreamingMixin
 3
 4class StreamingView(StreamingMixin, LiveView):
 5    template_name = 'streaming.html'
 6
 7    SAMPLE_RESPONSE = (
 8        "Django is a high-level Python web framework "
 9        "that encourages rapid development and clean, "
10        "pragmatic design. Built by experienced developers, "
11        "it takes care of much of the hassle of web "
12        "development, so you can focus on writing your "
13        "app without needing to reinvent the wheel."
14    )
15
16    def mount(self, request):
17        self.tokens = []
18        self.streaming_active = False
19
20    @event_handler
21    def start_stream(self, prompt: str = "", **kwargs):
22        """Begin streaming a simulated LLM response"""
23        self.tokens = []
24        self.streaming_active = True
25        # Stream tokens one at a time
26        for word in self.SAMPLE_RESPONSE.split():
27            self.stream_token("response", word + " ")
28        self.streaming_active = False
29
30    def get_context_data(self, **kwargs):
31        return {
32            'tokens': self.tokens,
33            'streaming_active': self.streaming_active,
34        }

 1from djust import LiveView, event_handler
 2from djust.push import push_to_view
 3
 4class NotificationsView(LiveView):
 5    template_name = 'notifications.html'
 6
 7    def mount(self, request):
 8        self.notifications = []
 9        self.next_id = 1
10
11    @event_handler
12    def trigger_task(self, **kwargs):
13        """Simulate a background task completing"""
14        # In production, called from Celery/RQ:
15        push_to_view(
16            self.view_id,
17            "on_task_complete",
18            {"message": "Deployment finished!"}
19        )
20
21    @event_handler
22    def on_task_complete(self, message: str = "", **kwargs):
23        """Receive push from background task"""
24        self.notifications.append({
25            'id': self.next_id,
26            'message': message,
27            'type': 'success',
28        })
29        self.next_id += 1
30
31    @event_handler
32    def dismiss(self, id: int = None, **kwargs):
33        """Dismiss a notification"""
34        self.notifications = [
35            n for n in self.notifications if n['id'] != id
36        ]
37
38    def get_context_data(self, **kwargs):
39        return {'notifications': self.notifications}

 1from djust import LiveView, event_handler
 2from djust.mixins import UploadMixin
 3
 4class ChunkedUploadView(UploadMixin, LiveView):
 5    template_name = 'upload_chunked.html'
 6
 7    def mount(self, request):
 8        self.files = []
 9        self.progress = 0
10        self.uploading = False
11
12    def allow_upload(self):
13        """Configure upload constraints"""
14        return {
15            'max_size': '50MB',
16            'accept': ['.pdf', '.png', '.jpg', '.zip'],
17            'chunked': True,
18            'chunk_size': '1MB',
19        }
20
21    def on_upload_progress(self, filename, percent):
22        """Called as chunks arrive"""
23        self.progress = percent
24
25    def on_upload_complete(self, upload):
26        """Called when upload finishes"""
27        self.files.append({
28            'name': upload.filename,
29            'size': upload.size_display,
30        })
31        self.uploading = False
32        self.progress = 0
33
34    def get_context_data(self, **kwargs):
35        return {
36            'files': self.files,
37            'progress': self.progress,
38            'uploading': self.uploading,
39        }