django-spire 0.23.8__tar.gz → 0.23.10__tar.gz

{django_spire-0.23.8 → django_spire-0.23.10}/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2024 Stratus Advanced Technologies and Contributors.
+Copyright (c) 2025 Stratus Advanced Technologies and Contributors.
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

{django_spire-0.23.8 → django_spire-0.23.10}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: django-spire
-Version: 0.23.8
+Version: 0.23.10
 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.
+License: Copyright (c) 2025 Stratus Advanced Technologies and Contributors.
         
         Permission is hereby granted, free of charge, to any person
         obtaining a copy of this software and associated documentation

{django_spire-0.23.8 → django_spire-0.23.10}/django_spire/consts.py

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

django_spire-0.23.10/django_spire/contrib/progress/__init__.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from django_spire.contrib.progress.enums import ProgressStatus
+from django_spire.contrib.progress.tasks import ParallelTask, SequentialTask
+from django_spire.contrib.progress.session import ProgressSession
+
+
+__all__ = [
+    'ParallelTask',
+    'ProgressSession',
+    'ProgressStatus',
+    'SequentialTask',
+]

{django_spire-0.23.8 → django_spire-0.23.10}/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-0.23.10/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-0.23.10/django_spire/contrib/progress/static/django_spire/js/contrib/progress/progress.js

@@ -0,0 +1,65 @@
+class ProgressStream {
+    constructor(url, config = {}) {
+        this.url = url;
+
+        this.config = {
+            on_complete: config.on_complete || (() => {}),
+            on_error: config.on_error || (() => {}),
+            on_update: config.on_update || (() => {}),
+            redirect_delay: config.redirect_delay || 1000,
+            redirect_url: config.redirect_url || null,
+        };
+    }
+
+    _redirect() {
+        if (!this.config.redirect_url) {
+            return;
+        }
+
+        setTimeout(() => {
+            window.location.href = this.config.redirect_url;
+        }, this.config.redirect_delay);
+    }
+
+    async start() {
+        let response = await fetch(this.url);
+
+        if (!response.ok) {
+            this.config.on_error({ message: `HTTP ${response.status}` });
+            return;
+        }
+
+        let reader = response.body.getReader();
+        let decoder = new TextDecoder();
+
+        while (true) {
+            let { done, value } = await reader.read();
+
+            if (done) {
+                break;
+            }
+
+            let chunk = decoder.decode(value, { stream: true });
+            let lines = chunk.split('\n').filter(line => line.trim());
+
+            for (let line of lines) {
+                let data = JSON.parse(line);
+
+                this.config.on_update(data);
+
+                if (data.status === 'error') {
+                    this.config.on_error(data);
+                    return;
+                }
+
+                if (data.status === 'complete') {
+                    this.config.on_complete(data);
+                    this._redirect();
+                    return;
+                }
+            }
+        }
+    }
+}
+
+window.ProgressStream = ProgressStream;

django_spire-0.23.10/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-0.23.8 → django_spire-0.23.10}/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>

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

@@ -0,0 +1,115 @@
+{% 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-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="{
+            has_error: false,
+            message: 'Initializing...',
+            overall_percent: 0,
+            tasks: {},
+
+            async init() {
+                let stream = new ProgressStream(this.$el.dataset.streamUrl, {
+                    on_complete: () => {
+                        setTimeout(() => close_modal(), 500);
+                    },
+                    on_error: (data) => {
+                        this.has_error = true;
+                        this.message = data.message || 'An error occurred';
+                    },
+                    on_update: (data) => {
+                        this.overall_percent = data.overall_percent;
+                        this.tasks = data.tasks;
+                    },
+                    redirect_delay: parseInt(this.$el.dataset.redirectDelay),
+                    redirect_url: this.$el.dataset.redirectUrl,
+                });
+
+                await stream.start();
+            },
+
+            get_status_icon(status) {
+                if (status === 'complete') return 'bi-check-circle-fill text-success';
+                if (status === 'error') return 'bi-x-circle-fill text-danger';
+                if (status === 'running') return 'bi-arrow-repeat text-primary spin';
+                return 'bi-circle text-secondary';
+            }
+        }"
+    >
+        <div class="row g-3">
+            <div class="col-12" x-show="!has_error">
+                <template x-for="(task, task_id) in tasks" :key="task_id">
+                    <div class="mb-3">
+                        <div class="d-flex align-items-center mb-1">
+                            <i class="bi me-2" :class="get_status_icon(task.status)"></i>
+                            <span class="fw-medium" x-text="task.name"></span>
+                            <span class="ms-auto fs-7" x-text="task.percent + '%'"></span>
+                        </div>
+                        <div class="progress" style="height: 4px;">
+                            <div
+                                class="progress-bar"
+                                :class="task.status === 'error' ? 'bg-danger' : 'bg-success'"
+                                role="progressbar"
+                                :style="'width: ' + task.percent + '%'"
+                            ></div>
+                        </div>
+                        <small class="text-muted" x-text="task.message"></small>
+                    </div>
+                </template>
+
+                <div class="mt-4 pt-3 border-top">
+                    <div class="d-flex justify-content-between align-items-center mb-2">
+                        <span class="fw-semibold">Overall Progress</span>
+                        <span x-text="overall_percent + '%'"></span>
+                    </div>
+                    <div class="progress" style="height: 8px;">
+                        <div
+                            class="progress-bar bg-primary"
+                            role="progressbar"
+                            :style="'width: ' + overall_percent + '%'"
+                        ></div>
+                    </div>
+                </div>
+
+                <p class="text-app-secondary mb-0 fs-7 text-center mt-3">
+                    {% block progress_wait_message %}This may take a moment. Please do not close this window.{% endblock %}
+                </p>
+            </div>
+
+            <div class="col-12" x-show="has_error" x-cloak>
+                <div class="d-flex align-items-center justify-content-center py-4">
+                    <i class="bi bi-x-circle-fill text-danger me-3 fs-4"></i>
+                    <span class="fs-5" x-text="message"></span>
+                </div>
+                <div class="text-center">
+                    <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>
+
+    <style>
+        .spin {
+            animation: spin 1s linear infinite;
+        }
+        @keyframes spin {
+            from { transform: rotate(0deg); }
+            to { transform: rotate(360deg); }
+        }
+    </style>
+{% endblock %}

{django_spire-0.23.8 → django_spire-0.23.10}/django_spire/core/management/commands/spire_startapp_pkg/template/app/apps.py.template

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.apps import AppConfig
 
 

{django_spire-0.23.8 → django_spire-0.23.10}/django_spire/core/management/commands/spire_startapp_pkg/template/app/urls/__init__.py.template

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.urls.conf import include, path
 
 

{django_spire-0.23.8 → django_spire-0.23.10}/django_spire/core/management/commands/spire_startapp_pkg/template/app/urls/form_urls.py.template

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.urls import path
 
 from ${module_path}.views import form_views

{django_spire-0.23.8 → django_spire-0.23.10}/django_spire/core/management/commands/spire_startapp_pkg/template/app/urls/page_urls.py.template

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.urls import path
 
 from ${module_path}.views import page_views