django-spire 0.23.3__py3-none-any.whl → 0.23.5__py3-none-any.whl

django_spire/consts.py

@@ -1,4 +1,4 @@
-__VERSION__ = '0.23.3'
+__VERSION__ = '0.23.5'
 
 MAINTENANCE_MODE_SETTINGS_NAME = 'MAINTENANCE_MODE'
 

django_spire/contrib/generic_views/portal_views.py

@@ -129,7 +129,7 @@ def infinite_scrolling_view(
     if context_data is None:
         context_data = {}
 
-    default_batch_size = 25
+    default_batch_size = 50
 
     page = int(request.GET.get('page', 1))
 

django_spire/contrib/progress/__init__.py

@@ -1,10 +1,21 @@
+from django_spire.contrib.progress.enums import ProgressStatus
 from django_spire.contrib.progress.mixins import ProgressTrackingMixin
+from django_spire.contrib.progress.runner import TaskProgressUpdater
+from django_spire.contrib.progress.states import TaskState, TrackerState
+from django_spire.contrib.progress.task import ProgressMessages, Task, TaskResult
 from django_spire.contrib.progress.tracker import ProgressTracker
 from django_spire.contrib.progress.views import sse_stream_view
 
 
 __all__ = [
+    'ProgressMessages',
+    'ProgressStatus',
     'ProgressTracker',
     'ProgressTrackingMixin',
+    'Task',
+    'TaskProgressUpdater',
+    'TaskResult',
+    'TaskState',
+    'TrackerState',
     'sse_stream_view',
 ]

django_spire/contrib/progress/enums.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from enum import StrEnum
+
+
+class ProgressStatus(StrEnum):
+    COMPLETE = 'complete'
+    ERROR = 'error'
+    PENDING = 'pending'
+    PROCESSING = 'processing'

django_spire/contrib/progress/mixins.py

@@ -7,6 +7,8 @@ from django_spire.contrib.progress.tracker import ProgressTracker
 if TYPE_CHECKING:
     from typing import Any
 
+    from django_spire.contrib.progress.enums import ProgressStatus
+
 
 class ProgressTrackingMixin:
     _tracker: ProgressTracker | None = None
@@ -17,19 +19,18 @@ class ProgressTrackingMixin:
     @property
     def tracker(self) -> ProgressTracker:
         if self._tracker is None:
-            key = self.get_tracker_key()
-            self._tracker = ProgressTracker(key)
+            self._tracker = ProgressTracker(self.get_tracker_key())
 
         return self._tracker
 
+    def progress_error(self, message: str) -> None:
+        self.tracker.error(message)
+
     def update_progress(
         self,
-        step: str,
+        status: ProgressStatus,
         message: str,
         progress: int,
         **kwargs: Any
     ) -> None:
-        self.tracker.update(step, message, progress, **kwargs)
-
-    def progress_error(self, message: str) -> None:
-        self.tracker.error(message)
+        self.tracker.update(status, message, progress, **kwargs)

django_spire/contrib/progress/runner.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import math
+import random
+import threading
+import time
+
+from typing import TYPE_CHECKING
+
+from django_spire.contrib.progress.enums import ProgressStatus
+from django_spire.contrib.progress.task import ProgressMessages, Task, TaskResult
+
+if TYPE_CHECKING:
+    from typing import Any, Callable
+
+    from django_spire.contrib.progress.tracker import ProgressTracker
+
+
+class TaskProgressUpdater:
+    def __init__(self, tracker: ProgressTracker, task: Task) -> None:
+        self._messages = ProgressMessages()
+        self._task = task
+        self._tracker = tracker
+
+    def complete(self, message: str | None = None) -> None:
+        self._tracker._update_task(
+            self._task.name,
+            ProgressStatus.COMPLETE,
+            self._format(message or self._messages.complete),
+            100
+        )
+
+    def error(self, message: str) -> None:
+        self._tracker._update_task(
+            self._task.name,
+            ProgressStatus.ERROR,
+            self._format(message),
+            0
+        )
+
+    def start(self) -> None:
+        self._tracker._update_task(
+            self._task.name,
+            ProgressStatus.PROCESSING,
+            self._format(self._messages.starting),
+            2
+        )
+
+    def update(self, message: str, progress: int) -> None:
+        self._tracker._update_task(
+            self._task.name,
+            ProgressStatus.PROCESSING,
+            self._format(message),
+            progress
+        )
+
+    def _format(self, message: str) -> str:
+        return f'{self._task.label}: {message}'
+
+
+class ProgressSimulator:
+    def __init__(
+        self,
+        updater: TaskProgressUpdater,
+        max_progress: int = 90,
+        update_interval: float = 0.15
+    ) -> None:
+        self._max_progress = max_progress
+        self._messages = ProgressMessages()
+        self._update_interval = update_interval
+        self._updater = updater
+
+    def run(self, stop_event: threading.Event) -> None:
+        start_time = time.time()
+        duration = random.uniform(8.0, 15.0)
+
+        while not stop_event.is_set():
+            elapsed = time.time() - start_time
+            t = min(elapsed / duration, 1.0)
+
+            progress = self._ease_out_expo(t) * self._max_progress
+            progress = min(int(progress), self._max_progress)
+
+            jitter = random.uniform(-1.5, 1.5) if progress < self._max_progress - 5 else 0
+            progress = max(2, min(int(progress + jitter), self._max_progress))
+
+            message = self._get_message_for_progress(progress)
+            self._updater.update(message, progress)
+
+            if progress >= self._max_progress:
+                break
+
+            time.sleep(self._update_interval + random.uniform(0, 0.1))
+
+    def _ease_out_expo(self, t: float) -> float:
+        if t >= 1.0:
+            return 1.0
+
+        return 1.0 - math.pow(2, -10 * t)
+
+    def _get_message_for_progress(self, progress: int) -> str:
+        steps = self._messages.steps
+        index = min(int(progress / (self._max_progress / len(steps))), len(steps) - 1)
+
+        return steps[index]
+
+
+class TaskRunner:
+    def __init__(self, tracker: ProgressTracker, task: Task) -> None:
+        self._stop_event = threading.Event()
+        self._task = task
+        self._tracker = tracker
+        self._updater = TaskProgressUpdater(tracker, task)
+
+    def run_parallel(self, results: dict[str, TaskResult]) -> None:
+        self._execute(results, lambda: self._task.func())
+
+    def run_sequential(self, results: dict[str, TaskResult]) -> None:
+        unwrapped = {name: result.value for name, result in results.items()}
+        self._execute(results, lambda: self._task.func(unwrapped))
+
+    def stop(self) -> None:
+        self._stop_event.set()
+
+    def _execute(self, results: dict[str, TaskResult], executor: Callable[[], Any]) -> None:
+        simulator = ProgressSimulator(self._updater)
+        progress_thread = threading.Thread(target=simulator.run, args=(self._stop_event,))
+        progress_thread.start()
+
+        try:
+            self._updater.start()
+            value = executor()
+            results[self._task.name] = TaskResult(value=value)
+            self._updater.complete()
+        except BaseException as e:
+            results[self._task.name] = TaskResult(error=e)
+            self._updater.error(str(e))
+        finally:
+            self._stop_event.set()
+            progress_thread.join(timeout=1)

django_spire/contrib/progress/states.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from django_spire.contrib.progress.enums import ProgressStatus
+
+if TYPE_CHECKING:
+    from typing import Any
+
+
+@dataclass
+class TaskState:
+    message: str = 'Waiting...'
+    progress: int = 0
+    status: ProgressStatus = ProgressStatus.PENDING
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> TaskState:
+        return cls(
+            message=data.get('message', 'Waiting...'),
+            progress=data.get('progress', 0),
+            status=ProgressStatus(data.get('step', ProgressStatus.PENDING)),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            'message': self.message,
+            'progress': self.progress,
+            'step': self.status.value,
+        }
+
+
+@dataclass
+class TrackerState:
+    message: str = 'Initializing...'
+    progress: int = 0
+    status: ProgressStatus = ProgressStatus.PENDING
+    task_order: list[str] = field(default_factory=list)
+    tasks: dict[str, TaskState] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> TrackerState:
+        tasks = {
+            name: TaskState.from_dict(task_data)
+            for name, task_data in data.get('tasks', {}).items()
+        }
+
+        return cls(
+            message=data.get('message', 'Initializing...'),
+            progress=data.get('progress', 0),
+            status=ProgressStatus(data.get('step', ProgressStatus.PENDING)),
+            task_order=data.get('task_order', []),
+            tasks=tasks,
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            'message': self.message,
+            'progress': self.progress,
+            'step': self.status.value,
+            'task_order': self.task_order,
+            'tasks': {name: task.to_dict() for name, task in self.tasks.items()},
+        }

django_spire/contrib/progress/task.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any, Callable
+
+
+@dataclass
+class ProgressMessages:
+    complete: str = 'Complete'
+    error: str = 'Error'
+    starting: str = 'Starting...'
+    steps: list[str] = field(default_factory=lambda: [
+        'Initializing...',
+        'Processing...',
+        'Analyzing...',
+        'Working...',
+        'Almost there...',
+        'Finalizing...',
+    ])
+
+
+@dataclass
+class Task:
+    func: Callable
+    label: str
+    name: str
+    parallel: bool = False
+
+
+@dataclass
+class TaskResult:
+    error: BaseException | None = None
+    value: Any = None
+
+    @property
+    def failed(self) -> bool:
+        return self.error is not None

django_spire/contrib/progress/templates/django_spire/contrib/progress/modal/content.html

@@ -14,21 +14,28 @@
         data-redirect-url="{% block progress_redirect_url %}{% endblock %}"
         data-redirect-delay="{% block progress_redirect_delay %}1000{% endblock %}"
         x-data="{
-            step: 'starting',
+            tasks: {},
+            task_order: [],
+            overall_progress: 0,
             message: 'Initializing...',
-            progress: 0,
             has_error: false,
             stream: null,
+
             init() {
-                const stream_url = this.$el.dataset.streamUrl;
-                const redirect_url = this.$el.dataset.redirectUrl;
-                const redirect_delay = parseInt(this.$el.dataset.redirectDelay);
+                let stream_url = this.$el.dataset.streamUrl;
+                let redirect_url = this.$el.dataset.redirectUrl;
+                let redirect_delay = parseInt(this.$el.dataset.redirectDelay);
 
                 this.stream = new ProgressStream(stream_url, {
                     on_update: (data) => {
-                        this.step = data.step;
                         this.message = data.message;
-                        this.progress = data.progress;
+                        this.overall_progress = data.progress;
+                        if (data.task_order) {
+                            this.task_order = data.task_order;
+                        }
+                        if (data.tasks) {
+                            this.tasks = data.tasks;
+                        }
                     },
                     on_complete: (data) => {
                         setTimeout(() => {
@@ -43,30 +50,57 @@
                     redirect_delay: redirect_delay
                 });
                 this.stream.start();
+            },
+
+            format_task_name(name) {
+                return name.replace(/_/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+            },
+
+            get_progress_class(step) {
+                if (step === 'complete') return 'bg-success';
+                if (step === 'error') return 'bg-danger';
+                if (step === 'processing') return 'bg-app-accent';
+                return 'bg-secondary';
             }
         }"
     >
         <div class="row g-3">
             <div class="col-12" x-show="!has_error">
-                <div class="d-flex justify-content-between align-items-center mb-2">
-                    <span class="fs-6" x-text="message"></span>
-                    {% include 'django_spire/badge/accent_badge.html' with x_badge_text="progress + '%'" %}
-                </div>
-                <div class="progress" style="height: 8px;">
-                    <div
-                        class="progress-bar bg-app-accent"
-                        role="progressbar"
-                        :style="'width: ' + progress + '%'"
-                        :aria-valuenow="progress"
-                        aria-valuemin="0"
-                        aria-valuemax="100"
-                    ></div>
+                <template x-for="name in task_order" :key="name">
+                    <div class="mb-3" x-show="tasks[name]">
+                        <div class="d-flex justify-content-between align-items-center mb-1">
+                            <span class="fs-7" x-text="format_task_name(name)"></span>
+                            <span class="fs-7" x-text="tasks[name]?.progress + '%'"></span>
+                        </div>
+                        <div class="progress" style="height: 6px;">
+                            <div
+                                class="progress-bar"
+                                :class="get_progress_class(tasks[name]?.step)"
+                                role="progressbar"
+                                :style="'width: ' + (tasks[name]?.progress || 0) + '%'"
+                            ></div>
+                        </div>
+                    </div>
+                </template>
+
+                <div class="mt-4 pt-3 border-top">
+                    <div class="d-flex justify-content-between align-items-center mb-2">
+                        <span class="fs-6 fw-medium">Overall Progress</span>
+                        <span class="fs-6" x-text="overall_progress + '%'"></span>
+                    </div>
+                    <div class="progress" style="height: 8px;">
+                        <div
+                            class="progress-bar bg-app-accent"
+                            role="progressbar"
+                            :style="'width: ' + overall_progress + '%'"
+                        ></div>
+                    </div>
                 </div>
             </div>
 
             <div class="col-12" x-show="!has_error">
                 <p class="text-app-secondary mb-0 fs-7">
-                    {% block progress_wait_message %}We are processing your request. This may take a moment.{% endblock %}
+                    {% block progress_wait_message %}Processing your request. This may take a moment.{% endblock %}
                 </p>
             </div>
 

django_spire/contrib/progress/tracker.py

@@ -1,39 +1,245 @@
 from __future__ import annotations
 
+import logging
+import threading
+import time
+
 from typing import TYPE_CHECKING
 
 from django.core.cache import cache
 
+from django_spire.contrib.progress.enums import ProgressStatus
+from django_spire.contrib.progress.runner import TaskRunner
+from django_spire.contrib.progress.states import TaskState, TrackerState
+from django_spire.contrib.progress.task import Task, TaskResult
+
 if TYPE_CHECKING:
-    from typing import Any
+    from typing import Any, Callable
+
+
+log = logging.getLogger(__name__)
 
 
 class ProgressTracker:
     def __init__(self, key: str, timeout: int = 300) -> None:
-        self.key = f'progress_tracker_{key}'
-        self.timeout = timeout
+        self._key = f'progress_tracker_{key}'
+        self._lock = threading.Lock()
+        self._tasks: list[Task] = []
+        self._timeout = timeout
+
+    def clear(self) -> None:
+        cache.delete(self._key)
+
+    def complete(self, message: str = 'Complete!') -> None:
+        with self._lock:
+            state = self._get_state()
+            state.message = message
+            state.progress = 100
+            state.status = ProgressStatus.COMPLETE
+            self._save_state(state)
+
+    def error(self, message: str) -> None:
+        with self._lock:
+            state = self._get_state()
+            state.message = message
+            state.progress = 0
+            state.status = ProgressStatus.ERROR
+            self._save_state(state)
+
+    def execute(self) -> dict[str, Any] | None:
+        self._create_state()
+
+        error = False
+        results: dict[str, TaskResult] = {}
+
+        try:
+            error = self._execute_parallel_tasks(results)
+
+            if not error:
+                error = self._execute_sequential_tasks(results)
+
+            if not error:
+                self.complete()
+                time.sleep(1)
+        except BaseException:
+            log.exception('Progress tracker failed')
+            error = True
+
+        if error:
+            self.error('An unexpected error occurred')
+            time.sleep(2)
+
+        self.clear()
+
+        if error:
+            return None
+
+        return {name: result.value for name, result in results.items()}
+
+    def get(self) -> dict[str, Any] | None:
+        return cache.get(self._key)
+
+    def parallel(
+        self,
+        name: str,
+        func: Callable[[], Any],
+        label: str | None = None
+    ) -> ProgressTracker:
+        task = Task(
+            func=func,
+            label=label or self._generate_label(name),
+            name=name,
+            parallel=True,
+        )
+
+        self._tasks.append(task)
+
+        return self
+
+    def sequential(
+        self,
+        name: str,
+        func: Callable[[dict[str, Any]], Any],
+        label: str | None = None
+    ) -> ProgressTracker:
+        task = Task(
+            func=func,
+            label=label or self._generate_label(name),
+            name=name,
+            parallel=False,
+        )
+
+        self._tasks.append(task)
+
+        return self
+
+    def start(self) -> None:
+        state = TrackerState()
+        cache.set(self._key, state.to_dict(), timeout=self._timeout)
 
     def update(
         self,
-        step: str,
+        status: ProgressStatus,
         message: str,
         progress: int,
         **kwargs: Any
     ) -> None:
-        data = {
-            'step': step,
-            'message': message,
-            'progress': progress,
-            **kwargs
-        }
+        with self._lock:
+            state = self._get_state()
+            state.message = message
+            state.progress = progress
+            state.status = status
+            self._save_state(state, **kwargs)
 
-        cache.set(self.key, data, timeout=self.timeout)
+    def _calculate_overall_progress(self, state: TrackerState) -> int:
+        if not state.tasks:
+            return 0
 
-    def get(self) -> dict[str, Any] | None:
-        return cache.get(self.key)
+        total = sum(
+            task.progress
+            for task in state.tasks.values()
+        )
 
-    def clear(self) -> None:
-        cache.delete(self.key)
+        return int(total / len(state.tasks))
 
-    def error(self, message: str) -> None:
-        self.update('error', message, 0)
+    def _create_state(self) -> None:
+        task_names = [task.name for task in self._tasks]
+
+        state = TrackerState(
+            task_order=task_names,
+            tasks={name: TaskState() for name in task_names}
+        )
+
+        cache.set(self._key, state.to_dict(), timeout=self._timeout)
+
+    def _execute_parallel_tasks(self, results: dict[str, TaskResult]) -> bool:
+        tasks = [
+            task
+            for task in self._tasks if task.parallel
+        ]
+
+        if not tasks:
+            return False
+
+        runners: list[TaskRunner] = []
+        threads: list[threading.Thread] = []
+
+        for task in tasks:
+            runner = TaskRunner(self, task)
+            runners.append(runner)
+
+            thread = threading.Thread(target=runner.run_parallel, args=(results,))
+            threads.append(thread)
+            thread.start()
+
+        for thread in threads:
+            thread.join(timeout=self._timeout)
+
+            if thread.is_alive():
+                for runner in runners:
+                    runner.stop()
+
+                return True
+
+        return any(
+            results.get(task.name, TaskResult()).failed
+            for task in tasks
+        )
+
+    def _execute_sequential_tasks(self, results: dict[str, TaskResult]) -> bool:
+        tasks = [
+            task
+            for task in self._tasks
+            if not task.parallel
+        ]
+
+        for task in tasks:
+            runner = TaskRunner(self, task)
+            runner.run_sequential(results)
+
+            if results.get(task.name, TaskResult()).failed:
+                return True
+
+        return False
+
+    def _generate_label(self, name: str) -> str:
+        return name.replace('_', ' ').title()
+
+    def _get_state(self) -> TrackerState:
+        task_names = [task.name for task in self._tasks]
+        data = cache.get(self._key)
+
+        if data is None:
+            return TrackerState(
+                task_order=task_names,
+                tasks={name: TaskState() for name in task_names}
+            )
+
+        return TrackerState.from_dict(data)
+
+    def _save_state(self, state: TrackerState, **kwargs: Any) -> None:
+        data = state.to_dict()
+        data.update(kwargs)
+        cache.set(self._key, data, timeout=self._timeout)
+
+    def _update_task(
+        self,
+        name: str,
+        status: ProgressStatus,
+        message: str,
+        progress: int
+    ) -> None:
+        with self._lock:
+            state = self._get_state()
+
+            state.tasks[name] = TaskState(
+                message=message,
+                progress=progress,
+                status=status,
+            )
+
+            state.message = message
+            state.progress = self._calculate_overall_progress(state)
+            state.status = ProgressStatus.PROCESSING
+
+            self._save_state(state)

django_spire/contrib/progress/views.py

@@ -5,46 +5,60 @@ import time
 
 from typing import TYPE_CHECKING
 
+from django.core.cache import cache
 from django.http import StreamingHttpResponse
 
-from django_spire.contrib.progress.tracker import ProgressTracker
-
 if TYPE_CHECKING:
-    from typing import Callable
+    from typing import Callable, Generator
 
 
 def sse_stream_view(
     key: str,
     interval: float = 0.5,
-    should_continue: Callable[[dict], bool] | None = None
+    should_continue: Callable[[dict], bool] | None = None,
+    timeout: int = 300
 ) -> StreamingHttpResponse:
-    def event_stream() -> None:
-        tracker = ProgressTracker(key)
-        previous_progress = -1
+    cache_key = f'progress_tracker_{key}'
+
+    def event_stream() -> Generator[str, None, None]:
+        previous_data = None
+        start_time = time.time()
+        last_heartbeat = time.time()
+
+        yield ': connected\n\n'
 
         while True:
-            time.sleep(interval)
-            data = tracker.get()
+            elapsed = time.time() - start_time
+
+            if elapsed > timeout:
+                yield f'data: {json.dumps({"step": "error", "message": "Timeout", "progress": 0})}\n\n'
+                break
 
-            if data:
-                current_progress = data.get('progress', 0)
+            data = cache.get(cache_key)
 
-                if current_progress != previous_progress:
-                    yield f'data: {json.dumps(data)}\n\n'
-                    previous_progress = current_progress
+            if data and data != previous_data:
+                yield f'data: {json.dumps(data)}\n\n'
+                previous_data = data
+                last_heartbeat = time.time()
 
                 if should_continue and not should_continue(data):
-                        break
+                    break
 
-                if current_progress >= 100 or data.get('step') == 'error':
+                if data.get('progress', 0) >= 100 or data.get('step') == 'error':
                     break
 
+            if time.time() - last_heartbeat > 10:
+                yield ': heartbeat\n\n'
+                last_heartbeat = time.time()
+
+            time.sleep(interval)
+
     response = StreamingHttpResponse(
         event_stream(),
         content_type='text/event-stream'
     )
 
-    response['Cache-Control'] = 'no-cache'
+    response['Cache-Control'] = 'no-cache, no-store'
     response['X-Accel-Buffering'] = 'no'
 
     return response

django_spire/contrib/queryset/mixins.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
+import json
 from abc import abstractmethod
 from typing import Type
 
 from django.core.handlers.wsgi import WSGIRequest
 from django.db.models import QuerySet
 from django.forms import Form
-
 from django_spire.contrib.form.utils import show_form_errors
 from django_spire.contrib.queryset.enums import SessionFilterActionEnum
 from django_spire.contrib.session.controller import SessionController
@@ -18,16 +18,19 @@ class SessionFilterQuerySetMixin(QuerySet):
             self,
             request: WSGIRequest,
             session_key: str,
-            form_class: Type[Form]
+            form_class: Type[Form],
+            is_from_body: bool = False,
     ) -> QuerySet:
         # Session keys must match to process new queryset data
 
+        data = json.loads(request.body.decode('utf-8')) if is_from_body else request.GET
+
         try:
-            action = SessionFilterActionEnum(request.GET.get('action'))
+            action = SessionFilterActionEnum(data.get('action'))
         except ValueError:
             action = None
 
-        form = form_class(request.GET)
+        form = form_class(data)
 
         if form.is_valid():
             session = SessionController(request=request, session_key=session_key)
@@ -39,8 +42,9 @@ class SessionFilterQuerySetMixin(QuerySet):
             # Apply filters when the user submits the filter form
             if (
                     action == SessionFilterActionEnum.FILTER
-                    and session_key == request.GET.get('session_filter_key')
+                    and session_key == data.get('session_filter_key')
             ):
+
                 # Update session data
                 for key, value in form.cleaned_data.items():
                     session.add_data(key, value)
@@ -56,7 +60,6 @@ class SessionFilterQuerySetMixin(QuerySet):
             show_form_errors(request, form)
             return self
 
-
     @abstractmethod
     def bulk_filter(self, filter_data: dict) -> QuerySet:
         pass

django_spire/core/templates/django_spire/infinite_scroll/base.html

@@ -1,6 +1,6 @@
 <div
     x-data="{
-        batch_size: parseInt('{{ batch_size|default:25 }}'),
+        batch_size: parseInt('{{ batch_size|default:50 }}'),
         current_page: parseInt('{{ current_page|default:0 }}'),
         endpoint: '{{ endpoint }}',
         has_next: {{ has_next|default:'true'|yesno:'true,false' }},

django_spire/core/templates/django_spire/infinite_scroll/scroll.html

@@ -1,6 +1,6 @@
 <div
     x-data="{
-        batch_size: 25,
+        batch_size: 50,
         current_page: 0,
         endpoint: '',
         has_next: true,
@@ -16,7 +16,7 @@
         async init() {
             this.scroll_id = $id('scroll');
             this.endpoint = this.$el.dataset.endpoint || '';
-            this.batch_size = parseInt(this.$el.dataset.batchSize || '25');
+            this.batch_size = parseInt(this.$el.dataset.batchSize || '50');
 
             await this.$nextTick();
 
@@ -116,7 +116,7 @@
             this.observer.observe(trigger);
         },
     }"
-    data-batch-size="{{ batch_size|default:25 }}"
+    data-batch-size="{{ batch_size|default:50 }}"
     data-endpoint="{{ endpoint }}"
     :data-scroll-id="scroll_id"
     @item-mounted.window="handle_item_mounted($event)"

django_spire/core/templates/django_spire/table/element/loading_skeleton.html

@@ -3,8 +3,10 @@
         <template x-for="i in skeleton_count" :key="i">
             <tr class="skeleton-row" :style="average_row_height > 0 ? `height: ${average_row_height}px;` : ''">
                 <template x-for="j in column_count" :key="j">
-                    <td class="align-middle">
-                        <div class="skeleton-box" style="height: 25px; width: 90%;"></div>
+                    <td class="align-middle h-100">
+                        <div class="align-items-center d-flex h-100">
+                            <div class="skeleton-box" style="height: 20px; width: 90%;"></div>
+                        </div>
                     </td>
                 </template>
             </tr>

django_spire/core/templates/django_spire/table/element/refreshing_skeleton.html

@@ -3,8 +3,10 @@
         <template x-for="i in skeleton_count" :key="i">
             <tr class="skeleton-row" :style="average_row_height > 0 ? `height: ${average_row_height}px;` : ''">
                 <template x-for="j in column_count" :key="j">
-                    <td class="align-middle">
-                        <div class="skeleton-box" style="height: 25px; width: 90%;"></div>
+                    <td class="align-middle h-100">
+                        <div class="align-items-center d-flex h-100">
+                            <div class="skeleton-box" style="height: 20px; width: 90%;"></div>
+                        </div>
                     </td>
                 </template>
             </tr>

{django_spire-0.23.3.dist-info → django_spire-0.23.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-spire
-Version: 0.23.3
+Version: 0.23.5
 Summary: A project for Django Spire
 Author-email: Brayden Carlson <braydenc@stratusadv.com>, Nathan Johnson <nathanj@stratusadv.com>
 License: Copyright (c) 2024 Stratus Advanced Technologies and Contributors.

{django_spire-0.23.3.dist-info → django_spire-0.23.5.dist-info}/RECORD

@@ -1,6 +1,6 @@
 django_spire/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 django_spire/conf.py,sha256=c5Hs-7lk9T15254tOasiQ2ZTFLQIVJof9_QJDfm1PAI,933
-django_spire/consts.py,sha256=D5oVj-bY46n7ixDPRAWLe0rXEDktcI1whmswDjdKZOE,171
+django_spire/consts.py,sha256=YR9sX6FXBUPmKDLHD7b1mDlQp6jwxIOoAF39q4rJoiM,171
 django_spire/exceptions.py,sha256=L5ndRO5ftMmh0pHkO2z_NG3LSGZviJ-dDHNT73SzTNw,48
 django_spire/settings.py,sha256=B4GPqBGt_dmkt0Ay0j-IP-SZ6mY44m2Ap5kVSON5YLA,1005
 django_spire/urls.py,sha256=mKeZszb5U4iIGqddMb5Tt5fRC72U2wABEOi6mvOfEBU,656
@@ -168,6 +168,7 @@ django_spire/auth/group/templates/django_spire/auth/group/tab/user_list_card_tab
 django_spire/auth/group/templates/django_spire/auth/group/tab/user_list_card_tabs.html,sha256=qQRlAdB8TxfR0Z-crGGW5e5qgRx9qOCyYWfSX2EgpiM,548
 django_spire/auth/group/templatetags/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 django_spire/auth/group/templatetags/permission_tags.py,sha256=nK73ZKVhgCnIAQFpD_e4TZ_hHFt9GyPJCd1tZ_56CgY,256
+django_spire/auth/group/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 django_spire/auth/group/urls/__init__.py,sha256=efpuo6oZPZJsDS3-UjwkBOrcxKmyWk8M81OwsmZ4fJs,342
 django_spire/auth/group/urls/form_urls.py,sha256=bGofmsYfaWi7XRmaWS7zdFXgd8jNrIqNjVQVV_VdfvA,584
 django_spire/auth/group/urls/json_urls.py,sha256=uOQqYiYwtFN1KafQSW6vFzzvkMFaRB5jOjFtw21NpMM,423
@@ -198,6 +199,7 @@ django_spire/auth/permissions/consts.py,sha256=Sm7Oqq-lfOLpViar6yiZI2DPBYmNvbYBG
 django_spire/auth/permissions/decorators.py,sha256=LA169sW50UUDlnpuAJuUmRzb_nvGWrR_AsyNlKXWiBE,1502
 django_spire/auth/permissions/permissions.py,sha256=089AidHUVx0DcpGtfJ9DAN38dyUmoUuEp8cIem8O-Is,6187
 django_spire/auth/permissions/tools.py,sha256=vfoI6KNLHVSaEzo1YSdNoStna0OLaoY5Xb3UBnt-DRo,2460
+django_spire/auth/permissions/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 django_spire/auth/seeding/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 django_spire/auth/seeding/seed.py,sha256=TDbGgJb5XADk4STs5jU7VvHb9qWFWE1hhqjqsCCgn74,92
 django_spire/auth/seeding/seeder.py,sha256=t50d-13t2oEAHG1vgQ41qXMyq0tmPQ3jjZuFlR-BZug,722
@@ -319,7 +321,7 @@ django_spire/contrib/gamification/static/django_spire/css/contrib/gamification/g
 django_spire/contrib/gamification/templates/django_spire/contrib/gamification/effect/kapow.html,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 django_spire/contrib/generic_views/__init__.py,sha256=fJU5nY61oqFCK-osl1Hnr7W2FKc_ZWeFuEkADWqCKzA,245
 django_spire/contrib/generic_views/modal_views.py,sha256=nDiVW9uIqNGYQx6hbY_H1YoiXg-FEKOCFow2z0qQk4A,2041
-django_spire/contrib/generic_views/portal_views.py,sha256=Xb_gorC3JHqE2nik1eqdVOlUdLKmh8LOZDTO1nlgwwo,7894
+django_spire/contrib/generic_views/portal_views.py,sha256=03_CUGvdAC6TKp9d_wg5TO_mykhfTJLdSSlKsjzUzkA,7894
 django_spire/contrib/help/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 django_spire/contrib/help/apps.py,sha256=UM1IoIMFNaVaQdUfACTMfUkm541TqNhOMqlp9X47zBc,193
 django_spire/contrib/help/templates/django_spire/contrib/help/help_button.html,sha256=ikym1hVCy1OuBJnU0CWhi-aCPCrLsfP3stCs0OV3PFk,162
@@ -346,18 +348,22 @@ django_spire/contrib/pagination/templatetags/__init__.py,sha256=47DEQpj8HBSa-_TI
 django_spire/contrib/pagination/templatetags/pagination_tags.py,sha256=xE3zTDJZDdDvWf6D7fMyg_Vi0PW37OA3aZxCjOHDp4I,1173
 django_spire/contrib/performance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 django_spire/contrib/performance/decorators.py,sha256=xOjXX-3FVOEWqr2TTTqdh4lkIhmHTlROevOVgXDeyt8,507
-django_spire/contrib/progress/__init__.py,sha256=zfB13CHEfaGLA8ILNTmePG2efwBygpitqxA9CDplc0U,292
-django_spire/contrib/progress/mixins.py,sha256=970sYbaZq2WAey-kAVED5hskQFXNh4WeCBIgNJLfdFU,834
-django_spire/contrib/progress/tracker.py,sha256=VtzcD0pxCsq736RHPXJfspfC7qNdjb74Cl6VKI7U3Iw,870
-django_spire/contrib/progress/views.py,sha256=bBEbTktWMlizzrdchPn6G4EEnDqc64bNH7Vt005XF2E,1268
+django_spire/contrib/progress/__init__.py,sha256=YEXnnbomc32c2J7e3sXHjtLboZ-PijiZOguoVHPfoUQ,719
+django_spire/contrib/progress/enums.py,sha256=nwyfKxQno_ghGGTbpK8lRO1cY7dCfbxnnsQ4cSbkXBw,194
+django_spire/contrib/progress/mixins.py,sha256=V84LRtniFDLK2E5dKcSZNh-a1zTf9Ee7QXg1rDfoFHo,895
+django_spire/contrib/progress/runner.py,sha256=3jSqpdk2MJ7HPNutwF43Hs81O0NlzX4E9gnVaenhXUs,4445
+django_spire/contrib/progress/states.py,sha256=V7JU_nzpZN77TQFW0S51Gjil8xn8CKLKkAWDOpqzA8k,1908
+django_spire/contrib/progress/task.py,sha256=4pMbzOsjRRNqPKNohh08D39DRFpC3QomTCH5IdqQS0A,780
+django_spire/contrib/progress/tracker.py,sha256=xjGlEyKe5aiKW_KC8NKZ8F0BjQdFpLUqHz5Gr_C7jws,6490
+django_spire/contrib/progress/views.py,sha256=CwJu-L09tTiCpsjVuqzvMEKVqp6-etLDi7L9ibmlq8U,1694
 django_spire/contrib/progress/static/django_spire/css/contrib/progress/progress.css,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 django_spire/contrib/progress/static/django_spire/js/contrib/progress/progress.js,sha256=2Zuwiu1nWJpghzU-6fmf6s4qKLLyiZUcAJwB9-v5xWI,1701
 django_spire/contrib/progress/templates/django_spire/contrib/progress/card/card.html,sha256=2Ajv0UBJEGwc4InVe69aLe2u4K56yh2JAuvO6uH24j8,3353
-django_spire/contrib/progress/templates/django_spire/contrib/progress/modal/content.html,sha256=oZ7mOxzro5809wSHLe4A90PonAqcr_eVawR_xHKXIt8,3682
+django_spire/contrib/progress/templates/django_spire/contrib/progress/modal/content.html,sha256=Qxer-q4GBC5h8onzno2NUlPrXluw_tO1kWlGComQ98E,5232
 django_spire/contrib/queryset/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 django_spire/contrib/queryset/enums.py,sha256=nGUHwCVOCBfVXo-lrgyqRoEaMq0ZQAGOWnjALSFPjJU,108
 django_spire/contrib/queryset/filter_tools.py,sha256=o7OBB3Jjtyoj7aaWspkFKS2bv0BeMIigXz7DVvt6Ueo,1087
-django_spire/contrib/queryset/mixins.py,sha256=Y_tK9ECr1cb_7AywpNaFKmqxRmNzvNuSCDyqVmfNcCE,2096
+django_spire/contrib/queryset/mixins.py,sha256=-fnk0nmfTUBa7dbA0Eb6ou82x0b5Kj5NnDtH654yDf8,2217
 django_spire/contrib/seeding/__init__.py,sha256=mHKO8a7fCAf70BWYjgyGgBDfssPtb3Pp9IxCVVI_4-M,112
 django_spire/contrib/seeding/field/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 django_spire/contrib/seeding/field/base.py,sha256=SK8EYSsLgMRgosY8bRb3X27RpL7cq55VETf6Q_pYYr4,1198
@@ -664,8 +670,8 @@ django_spire/core/templates/django_spire/forms/elements/dict_element.html,sha256
 django_spire/core/templates/django_spire/forms/elements/list_element.html,sha256=NbKavjm9qlSUnl5sao3xZILT-bW-TmIFB3Bqy0NfZkg,682
 django_spire/core/templates/django_spire/forms/elements/value_element.html,sha256=LaOR2ggmf-J_cPCVHjNoD4l_858zHCRA58T_ZB3EIkE,57
 django_spire/core/templates/django_spire/forms/widgets/json_tree_widget.html,sha256=dykf6xYRZ477i6SgcGR3TSnxDwLsu2p3FR45hEr4DF8,1489
-django_spire/core/templates/django_spire/infinite_scroll/base.html,sha256=x4JJgXTnWXTRz2laFHBW5jpD4D9sU-P8eAUDgEc3-UU,10875
-django_spire/core/templates/django_spire/infinite_scroll/scroll.html,sha256=osZx9nsCypvnZY3dva_52MoZQRkLK0kOCMnGxHvhsUw,4311
+django_spire/core/templates/django_spire/infinite_scroll/base.html,sha256=--8DAhRYwAfowKWKLrnfdvh4rNTeBXyziE82fReFfnc,10875
+django_spire/core/templates/django_spire/infinite_scroll/scroll.html,sha256=5new-JbLIo6D9zurYN39hy41moJDj_2obeY1v9VWk_Q,4311
 django_spire/core/templates/django_spire/infinite_scroll/element/footer.html,sha256=22yxDuYB2vKqaDaMsARStrYTYoHtPGYmK6Xl9XQdwH8,391
 django_spire/core/templates/django_spire/item/infinite_scroll_item.html,sha256=NMx3jQwtcKJiKtzbQXaXI3eWOtnJFiZhCI13tLTxSnc,1011
 django_spire/core/templates/django_spire/item/item.html,sha256=9AD6qRcYIb7q-EcmWlRUFiK8XfnmPBSS5NOsXdKEAAA,1217
@@ -711,8 +717,8 @@ django_spire/core/templates/django_spire/table/element/child_row.html,sha256=B0f
 django_spire/core/templates/django_spire/table/element/expandable_row.html,sha256=sAzzUeGishdYRUqs9t4lduxuxZaOzUYNhMfMytRLq90,1516
 django_spire/core/templates/django_spire/table/element/footer.html,sha256=fVxbDrVj4C9jIswkri7B2Dr4nEr2Lf_EPPULMU3mRs0,312
 django_spire/core/templates/django_spire/table/element/header.html,sha256=NBx9Lfn3Dav5uEb-SlyB-vhZapCzxbfc2xxmrg7Bu3c,647
-django_spire/core/templates/django_spire/table/element/loading_skeleton.html,sha256=b3EGdrXoFT1tku4dA_sWv8FAxck5ZZhef_9FumYZYNA,577
-django_spire/core/templates/django_spire/table/element/refreshing_skeleton.html,sha256=nCoDCITzPewTYJ-vPDZiSCv1qhdhT2BqMwygIdF1tYg,562
+django_spire/core/templates/django_spire/table/element/loading_skeleton.html,sha256=4YIsTLGjAC6T0idBjjkeqTkfXBb7sKJAUXWVbhla6ng,688
+django_spire/core/templates/django_spire/table/element/refreshing_skeleton.html,sha256=nShQpQPP00z70Kvpm3CDpXpq_J_bjpBjv1BD4aVEmPE,673
 django_spire/core/templates/django_spire/table/element/row.html,sha256=BoNZTjRs_cVG11CKK5VVocAq4p-UtB79FnhGPfSXKEo,3379
 django_spire/core/templates/django_spire/table/element/trigger.html,sha256=KixtqIshbs8V1QSupIMxTe0UYJbK2oJIsqD8fZYxAOs,66
 django_spire/core/templates/django_spire/table/item/no_data_item.html,sha256=PxTyI98edGtMxRdRzuEh1P_uOKRY_X5awrWXQsVb1jI,441
@@ -1195,8 +1201,8 @@ django_spire/theme/urls/page_urls.py,sha256=S8nkKkgbhG3XHI3uMUL-piOjXIrRkuY2UlM_
 django_spire/theme/views/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 django_spire/theme/views/json_views.py,sha256=PWwVTaty0BVGbj65L5cxex6JNhc-xVAI_rEYjbJWqEM,1893
 django_spire/theme/views/page_views.py,sha256=WenjOa6Welpu3IMolY56ZwBjy4aK9hpbiMNuygjAl1A,3922
-django_spire-0.23.3.dist-info/licenses/LICENSE.md,sha256=tlTbOtgKoy-xAQpUk9gPeh9O4oRXCOzoWdW3jJz0wnA,1091
-django_spire-0.23.3.dist-info/METADATA,sha256=jiN0athZqM7GqaqMwLkR09-VP5oNYXUUT3PnQfGzbAw,5127
-django_spire-0.23.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-django_spire-0.23.3.dist-info/top_level.txt,sha256=xf3QV1e--ONkVpgMDQE9iqjQ1Vg4--_6C8wmO-KxPHQ,13
-django_spire-0.23.3.dist-info/RECORD,,
+django_spire-0.23.5.dist-info/licenses/LICENSE.md,sha256=tlTbOtgKoy-xAQpUk9gPeh9O4oRXCOzoWdW3jJz0wnA,1091
+django_spire-0.23.5.dist-info/METADATA,sha256=NsK-z_MdElXotF4ZnWMERuHNpLZODw6_kRI_lO7bt-Q,5127
+django_spire-0.23.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+django_spire-0.23.5.dist-info/top_level.txt,sha256=xf3QV1e--ONkVpgMDQE9iqjQ1Vg4--_6C8wmO-KxPHQ,13
+django_spire-0.23.5.dist-info/RECORD,,