django-spire 0.23.4__tar.gz → 0.23.6__tar.gz

{django_spire-0.23.4 → django_spire-0.23.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-spire
-Version: 0.23.4
+Version: 0.23.6
 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.4 → django_spire-0.23.6}/django_spire/consts.py

@@ -1,4 +1,4 @@
-__VERSION__ = '0.23.4'
+__VERSION__ = '0.23.6'
 
 MAINTENANCE_MODE_SETTINGS_NAME = 'MAINTENANCE_MODE'
 

{django_spire-0.23.4 → django_spire-0.23.6}/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-0.23.6/django_spire/contrib/progress/__init__.py

@@ -0,0 +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-0.23.6/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-0.23.4 → django_spire-0.23.6}/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-0.23.6/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-0.23.6/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-0.23.6/django_spire/contrib/progress/static/django_spire/js/contrib/progress/progress.js

@@ -0,0 +1,131 @@
+class ProgressStream {
+    constructor(url, config = {}) {
+        this.url = url;
+        this.controller = null;
+        this.is_running = false;
+
+        this.config = {
+            on_update: config.on_update || (() => {}),
+            on_complete: config.on_complete || (() => {}),
+            on_error: config.on_error || (() => {}),
+            redirect_on_complete: config.redirect_on_complete || null,
+            redirect_delay: config.redirect_delay || 1000
+        };
+    }
+
+    async start() {
+        if (this.is_running) return;
+
+        this.is_running = true;
+        this.controller = new AbortController();
+
+        try {
+            let response = await this._fetch();
+
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+
+            await this._read_stream(response);
+        } catch (error) {
+            this._handle_error(error);
+        }
+    }
+
+    stop() {
+        if (!this.is_running) return;
+
+        this.is_running = false;
+
+        if (this.controller) {
+            this.controller.abort();
+            this.controller = null;
+        }
+    }
+
+    async _fetch() {
+        return fetch(this.url, {
+            method: 'POST',
+            signal: this.controller.signal,
+            headers: {
+                'X-CSRFToken': get_cookie('csrftoken'),
+            }
+        });
+    }
+
+    async _read_stream(response) {
+        let reader = response.body.getReader();
+        let decoder = new TextDecoder();
+        let buffer = '';
+
+        while (this.is_running) {
+            let { done, value } = await reader.read();
+
+            if (done) break;
+
+            buffer += decoder.decode(value, { stream: true });
+            buffer = this._process_buffer(buffer);
+        }
+    }
+
+    _process_buffer(buffer) {
+        let lines = buffer.split('\n');
+        let remainder = lines.pop();
+
+        for (let line of lines) {
+            if (line.startsWith('data: ')) {
+                this._handle_message(line.slice(6));
+            }
+        }
+
+        return remainder;
+    }
+
+    _handle_message(json_string) {
+        let data;
+
+        try {
+            data = JSON.parse(json_string);
+        } catch {
+            return;
+        }
+
+        this.config.on_update(data);
+
+        if (data.step === 'error') {
+            this.config.on_error(data);
+            this.stop();
+            return;
+        }
+
+        if (data.progress >= 100) {
+            this.config.on_complete(data);
+            this.stop();
+            this._redirect();
+        }
+    }
+
+    _handle_error(error) {
+        if (error.name === 'AbortError') return;
+
+        console.error('ProgressStream error:', error);
+
+        this.config.on_error({
+            step: 'error',
+            message: 'Connection error',
+            progress: 0
+        });
+
+        this.stop();
+    }
+
+    _redirect() {
+        if (!this.config.redirect_on_complete) return;
+
+        setTimeout(() => {
+            window.location.href = this.config.redirect_on_complete;
+        }, this.config.redirect_delay);
+    }
+}
+
+window.ProgressStream = ProgressStream;

django_spire-0.23.6/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-0.23.6/django_spire/contrib/progress/templates/django_spire/contrib/progress/modal/content.html

@@ -0,0 +1,124 @@
+{% extends 'django_spire/modal/content/modal_title_content.html' %}
+
+{% block modal_content_title %}
+    <i class="bi bi-magic"></i>
+    {% block progress_modal_title %}Processing{% endblock %}
+{% endblock %}
+
+{% block modal_content_close_button %}
+{% endblock %}
+
+{% block modal_content_content %}
+    <div
+        data-stream-url="{% block progress_stream_url %}{% endblock %}"
+        data-redirect-url="{% block progress_redirect_url %}{% endblock %}"
+        data-redirect-delay="{% block progress_redirect_delay %}1000{% endblock %}"
+        x-data="{
+            tasks: {},
+            task_order: [],
+            overall_progress: 0,
+            message: 'Initializing...',
+            has_error: false,
+            stream: null,
+
+            init() {
+                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.message = data.message;
+                        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(() => {
+                            close_modal();
+                        }, 500);
+                    },
+                    on_error: (data) => {
+                        this.has_error = true;
+                        this.message = data.message;
+                    },
+                    redirect_on_complete: redirect_url,
+                    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">
+                <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 %}Processing your request. This may take a moment.{% endblock %}
+                </p>
+            </div>
+
+            <div class="col-12" x-show="has_error" x-cloak>
+                <div class="row g-2">
+                    <div class="col-12">
+                        {% include 'django_spire/element/attribute_element.html' with attribute_title='Error' %}
+                        <span class="fs-6 text-app-danger" x-text="message"></span>
+                    </div>
+                    <div class="col-12">
+                        <span @click="close_modal()">
+                            {% block progress_error_button %}
+                                {% include 'django_spire/button/primary_button.html' with button_text='Close' %}
+                            {% endblock %}
+                        </span>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+{% endblock %}