django-spire 0.23.8__py3-none-any.whl → 0.23.10__py3-none-any.whl

django_spire/consts.py

@@ -1,4 +1,4 @@
-__VERSION__ = '0.23.8'
+__VERSION__ = '0.23.10'
 
 MAINTENANCE_MODE_SETTINGS_NAME = 'MAINTENANCE_MODE'
 

django_spire/contrib/progress/__init__.py

@@ -1,19 +1,13 @@
+from __future__ import annotations
+
 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.tasks import ParallelTask, SequentialTask
+from django_spire.contrib.progress.session import ProgressSession
 
 
 __all__ = [
-    'ProgressMessages',
+    'ParallelTask',
+    'ProgressSession',
     'ProgressStatus',
-    'ProgressTracker',
-    'ProgressTrackingMixin',
-    'Task',
-    'TaskProgressUpdater',
-    'TaskResult',
-    'TaskState',
-    'TrackerState'
+    'SequentialTask',
 ]

django_spire/contrib/progress/enums.py

@@ -5,6 +5,7 @@ from enum import StrEnum
 
 class ProgressStatus(StrEnum):
     COMPLETE = 'complete'
+    COMPLETING = 'completing'
     ERROR = 'error'
     PENDING = 'pending'
-    PROCESSING = 'processing'
+    RUNNING = 'running'

django_spire/contrib/progress/session.py

@@ -0,0 +1,283 @@
+from __future__ import annotations
+
+import json
+import threading
+import time
+import uuid
+
+from typing import TYPE_CHECKING
+
+from django.core.cache import cache
+
+from django_spire.contrib.progress.enums import ProgressStatus
+from django_spire.contrib.progress.tasks import ParallelTask, SequentialTask
+
+if TYPE_CHECKING:
+    from typing_extensions import Any, Callable, Generator
+
+
+SIMULATION_MESSAGES = [
+    'Initializing...',
+    'Processing...',
+    'Analyzing...',
+    'Generating...',
+    'Finalizing...',
+]
+
+
+class ProgressSession:
+    _CACHE_PREFIX = 'progress_session:'
+    _CACHE_TIMEOUT = 300
+    _COMPLETION_INCREMENT = 3.0
+    _COMPLETION_INTERVAL = 0.03
+    _MAX_SIMULATED_PERCENT = 85
+    _SIMULATION_INTERVAL = 0.1
+
+    def __init__(self, session_id: str, tasks: dict[str, str]) -> None:
+        self._lock = threading.Lock()
+        self._simulation_threads: dict[str, tuple[threading.Event, threading.Thread]] = {}
+
+        self._tasks: dict[str, dict[str, Any]] = {
+            task_id: {
+                'complete_message': '',
+                'message': '',
+                'name': name,
+                'percent': 0.0,
+                'status': ProgressStatus.PENDING,
+            }
+            for task_id, name in tasks.items()
+        }
+
+        self.session_id = session_id
+
+    def _calculate_increment(self, current_percent: float) -> float:
+        remaining = self._MAX_SIMULATED_PERCENT - current_percent
+        ratio = remaining / self._MAX_SIMULATED_PERCENT
+        eased = ratio * ratio
+        increment = 0.8 * eased
+
+        return max(increment, 0.05)
+
+    def _calculate_message_index(self, percent: float) -> int:
+        message_index = int((percent / 100) * len(SIMULATION_MESSAGES))
+
+        return min(message_index, len(SIMULATION_MESSAGES) - 1)
+
+    def _delete(self) -> None:
+        cache.delete(f'{self._CACHE_PREFIX}{self.session_id}')
+
+    def _save(self) -> None:
+        data = {
+            'session_id': self.session_id,
+            'tasks': {
+                task_id: {
+                    'complete_message': task['complete_message'],
+                    'message': task['message'],
+                    'name': task['name'],
+                    'percent': task['percent'],
+                    'status': task['status'].value,
+                }
+                for task_id, task in self._tasks.items()
+            },
+        }
+
+        cache.set(f'{self._CACHE_PREFIX}{self.session_id}', data, timeout=self._CACHE_TIMEOUT)
+
+    def _simulate_progress(
+        self,
+        task_id: str,
+        stop_event: threading.Event,
+    ) -> None:
+        while not stop_event.is_set():
+            with self._lock:
+                if task_id not in self._tasks:
+                    continue
+
+                task = self._tasks[task_id]
+
+                if task['status'] == ProgressStatus.RUNNING:
+                    self._tick_running(task)
+
+                if task['status'] == ProgressStatus.COMPLETING:
+                    if self._tick_completing(task):
+                        return
+
+            interval = self._COMPLETION_INTERVAL if task['status'] == ProgressStatus.COMPLETING else self._SIMULATION_INTERVAL
+            stop_event.wait(interval)
+
+    def _tick_completing(self, task: dict[str, Any]) -> bool:
+        if task['percent'] < 100.0:
+            task['percent'] = min(task['percent'] + self._COMPLETION_INCREMENT, 100.0)
+            self._save()
+            return False
+
+        task['status'] = ProgressStatus.COMPLETE
+        task['message'] = task['complete_message']
+        self._save()
+
+        return True
+
+    def _tick_running(self, task: dict[str, Any]) -> None:
+        if task['percent'] >= self._MAX_SIMULATED_PERCENT:
+            return
+
+        increment = self._calculate_increment(task['percent'])
+        task['percent'] = min(task['percent'] + increment, self._MAX_SIMULATED_PERCENT)
+        task['message'] = SIMULATION_MESSAGES[self._calculate_message_index(task['percent'])]
+
+        self._save()
+
+    @property
+    def has_error(self) -> bool:
+        tasks = [
+            task['status'] == ProgressStatus.ERROR
+            for task in self._tasks.values()
+        ]
+
+        return any(tasks)
+
+    @property
+    def is_complete(self) -> bool:
+        tasks = [
+            task['status'] == ProgressStatus.COMPLETE
+            for task in self._tasks.values()
+        ]
+
+        return all(tasks)
+
+    @property
+    def is_running(self) -> bool:
+        tasks = [
+            task['status'] in (ProgressStatus.RUNNING, ProgressStatus.COMPLETING)
+            for task in self._tasks.values()
+        ]
+
+        return any(tasks)
+
+    @property
+    def overall_percent(self) -> int:
+        if not self._tasks:
+            return 0
+
+        total_percent = sum(task['percent'] for task in self._tasks.values())
+
+        return int(total_percent / len(self._tasks))
+
+    @property
+    def status(self) -> ProgressStatus:
+        if self.has_error:
+            return ProgressStatus.ERROR
+
+        if self.is_complete:
+            return ProgressStatus.COMPLETE
+
+        if self.is_running:
+            return ProgressStatus.RUNNING
+
+        return ProgressStatus.PENDING
+
+    def add_parallel(self, task_id: str, future: Any) -> ParallelTask:
+        return ParallelTask(self, task_id, future)
+
+    def add_sequential(self, task_id: str, func: Callable, *args: Any, **kwargs: Any) -> SequentialTask:
+        return SequentialTask(self, task_id, func, *args, **kwargs)
+
+    def complete(self, task_id: str, message: str | None = None) -> None:
+        with self._lock:
+            if task_id in self._tasks:
+                task = self._tasks[task_id]
+                task['status'] = ProgressStatus.COMPLETING
+                task['complete_message'] = message or f'{task["name"]} complete'
+                task['message'] = 'Completing...'
+                self._save()
+
+    def error(self, task_id: str, message: str | None = None) -> None:
+        if task_id in self._simulation_threads:
+            stop_event, _ = self._simulation_threads[task_id]
+            stop_event.set()
+            del self._simulation_threads[task_id]
+
+        with self._lock:
+            if task_id in self._tasks:
+                task = self._tasks[task_id]
+                task['status'] = ProgressStatus.ERROR
+                task['message'] = message or f'{task["name"]} failed'
+                self._save()
+
+    def start(self, task_id: str) -> None:
+        with self._lock:
+            if task_id in self._tasks:
+                task = self._tasks[task_id]
+                task['percent'] = 0.0
+                task['status'] = ProgressStatus.RUNNING
+                task['message'] = SIMULATION_MESSAGES[0]
+                self._save()
+
+        stop_event = threading.Event()
+
+        thread = threading.Thread(
+            target=self._simulate_progress,
+            args=(task_id, stop_event),
+            daemon=True,
+        )
+
+        self._simulation_threads[task_id] = (stop_event, thread)
+        thread.start()
+
+    def stream(self, poll_interval: float = 0.05) -> Generator[str, None, None]:
+        while True:
+            with self._lock:
+                data = self.to_dict()
+
+            yield f'{json.dumps(data)}\n'
+
+            if self.is_complete or self.has_error:
+                self._delete()
+                break
+
+            time.sleep(poll_interval)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            'overall_percent': self.overall_percent,
+            'session_id': self.session_id,
+            'status': self.status.value,
+            'tasks': {
+                task_id: {
+                    'message': task['message'],
+                    'name': task['name'],
+                    'percent': int(task['percent']),
+                    'status': task['status'].value if task['status'] != ProgressStatus.COMPLETING else ProgressStatus.RUNNING.value,
+                }
+                for task_id, task in self._tasks.items()
+            },
+        }
+
+    @classmethod
+    def create(cls, tasks: dict[str, str]) -> ProgressSession:
+        session_id = str(uuid.uuid4())
+        session = cls(session_id, tasks)
+        session._save()
+        return session
+
+    @classmethod
+    def get(cls, session_id: str) -> ProgressSession | None:
+        data = cache.get(f'{cls._CACHE_PREFIX}{session_id}')
+
+        if data is None:
+            return None
+
+        session = cls(data['session_id'], {})
+
+        session._tasks = {
+            task_id: {
+                'complete_message': task['complete_message'],
+                'message': task['message'],
+                'name': task['name'],
+                'percent': task['percent'],
+                'status': ProgressStatus(task['status']),
+            }
+            for task_id, task in data['tasks'].items()
+        }
+
+        return session

django_spire/contrib/progress/static/django_spire/js/contrib/progress/progress.js

@@ -1,87 +1,65 @@
 class ProgressStream {
     constructor(url, config = {}) {
         this.url = url;
-        this.is_running = false;
-        this.poll_interval = null;
 
         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,
+            on_update: config.on_update || (() => {}),
             redirect_delay: config.redirect_delay || 1000,
-            poll_interval: config.poll_interval || 1000
+            redirect_url: config.redirect_url || null,
         };
     }
 
-    async start() {
-        if (this.is_running) return;
+    _redirect() {
+        if (!this.config.redirect_url) {
+            return;
+        }
 
-        this.is_running = true;
-        this._start_polling();
+        setTimeout(() => {
+            window.location.href = this.config.redirect_url;
+        }, this.config.redirect_delay);
     }
 
-    stop() {
-        if (!this.is_running) return;
-
-        this.is_running = false;
+    async start() {
+        let response = await fetch(this.url);
 
-        if (this.poll_interval) {
-            clearInterval(this.poll_interval);
-            this.poll_interval = null;
+        if (!response.ok) {
+            this.config.on_error({ message: `HTTP ${response.status}` });
+            return;
         }
-    }
-
-    _start_polling() {
-        this._poll();
 
-        this.poll_interval = setInterval(() => {
-            if (this.is_running) {
-                this._poll();
-            }
-        }, this.config.poll_interval);
-    }
+        let reader = response.body.getReader();
+        let decoder = new TextDecoder();
 
-    async _poll() {
-        try {
-            let response = await fetch(this.url, {
-                method: 'POST',
-                headers: {
-                    'X-CSRFToken': get_cookie('csrftoken'),
-                }
-            });
+        while (true) {
+            let { done, value } = await reader.read();
 
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}`);
+            if (done) {
+                break;
             }
 
-            let data = await response.json();
+            let chunk = decoder.decode(value, { stream: true });
+            let lines = chunk.split('\n').filter(line => line.trim());
 
-            this.config.on_update(data);
+            for (let line of lines) {
+                let data = JSON.parse(line);
 
-            if (data.step === 'error') {
-                this.config.on_error(data);
-                this.stop();
-                return;
-            }
+                this.config.on_update(data);
 
-            if (data.progress >= 100) {
-                this.config.on_complete(data);
-                this.stop();
-                this._redirect();
+                if (data.status === 'error') {
+                    this.config.on_error(data);
+                    return;
+                }
+
+                if (data.status === 'complete') {
+                    this.config.on_complete(data);
+                    this._redirect();
+                    return;
+                }
             }
-        } catch (error) {
-            console.warn('Poll error:', error.message);
         }
     }
-
-    _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/contrib/progress/tasks.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import threading
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any, Callable
+
+    from django_spire.contrib.progress.session import ProgressSession
+
+
+class ParallelTask:
+    def __init__(self, session: ProgressSession, task_id: str, future: Any) -> None:
+        self._future = future
+        self._session = session
+        self._task_id = task_id
+
+        self._session.start(task_id)
+
+        thread = threading.Thread(
+            target=self._wait_for_completion,
+            daemon=True,
+        )
+        thread.start()
+
+    def _wait_for_completion(self) -> None:
+        try:
+            _ = self._future.result
+            self._session.complete(self._task_id)
+        except Exception:
+            self._session.error(self._task_id)
+
+    @property
+    def result(self) -> Any:
+        return self._future.result
+
+
+class SequentialTask:
+    def __init__(
+        self,
+        session: ProgressSession,
+        task_id: str,
+        func: Callable,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        self._exception: Exception | None = None
+        self._result: Any = None
+        self._session = session
+        self._task_id = task_id
+
+        self._session.start(task_id)
+
+        try:
+            self._result = func(*args, **kwargs)
+            self._session.complete(task_id)
+        except Exception as e:
+            self._exception = e
+            self._session.error(task_id)
+
+    @property
+    def result(self) -> Any:
+        if self._exception is not None:
+            raise self._exception
+
+        return self._result

django_spire/contrib/progress/templates/django_spire/contrib/progress/card/card.html

@@ -7,35 +7,36 @@
 
 {% block card_title_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 %}"
+        data-redirect-url="{% block progress_redirect_url %}{% endblock %}"
+        data-stream-url="{% block progress_stream_url %}{% endblock %}"
         x-data="{
-            step: 'starting',
-            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);
+            message: 'Initializing...',
+            overall_percent: 0,
 
-                this.stream = new ProgressStream(stream_url, {
-                    on_update: (data) => {
-                        this.step = data.step;
-                        this.message = data.message;
-                        this.progress = data.progress;
-                    },
-                    on_complete: (data) => {},
+            async init() {
+                let stream = new ProgressStream(this.$el.dataset.streamUrl, {
+                    on_complete: () => {},
                     on_error: (data) => {
                         this.has_error = true;
-                        this.message = data.message;
+                        this.message = data.message || 'An error occurred';
+                    },
+                    on_update: (data) => {
+                        this.overall_percent = data.overall_percent;
+
+                        let tasks = Object.values(data.tasks);
+                        let running_task = tasks.find(t => t.status === 'running');
+
+                        if (running_task) {
+                            this.message = running_task.message;
+                        }
                     },
-                    redirect_on_complete: redirect_url,
-                    redirect_delay: redirect_delay
+                    redirect_delay: parseInt(this.$el.dataset.redirectDelay),
+                    redirect_url: this.$el.dataset.redirectUrl,
                 });
-                this.stream.start();
+
+                await stream.start();
             }
         }"
     >
@@ -43,14 +44,14 @@
             <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 + '%'" %}
+                    {% include 'django_spire/badge/accent_badge.html' with x_badge_text="overall_percent + '%'" %}
                 </div>
                 <div class="progress" style="height: 8px;">
                     <div
                         class="progress-bar bg-app-accent"
                         role="progressbar"
-                        :style="'width: ' + progress + '%'"
-                        :aria-valuenow="progress"
+                        :style="'width: ' + overall_percent + '%'"
+                        :aria-valuenow="overall_percent"
                         aria-valuemin="0"
                         aria-valuemax="100"
                     ></div>