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

django_spire/contrib/pagination/tests/test_pagination.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+from django.core.paginator import Page
+from django.test import RequestFactory, TestCase
+
+from django_spire.contrib.pagination.pagination import paginate_list
+from django_spire.contrib.pagination.templatetags.pagination_tags import (
+    get_elided_page_range,
+    pagination_url,
+)
+
+
+class TestPaginateList(TestCase):
+    def setUp(self) -> None:
+        self.object_list = list(range(100))
+
+    def test_custom_page_number(self) -> None:
+        result = paginate_list(self.object_list, page_number=2)
+
+        assert result.number == 2
+
+    def test_custom_per_page(self) -> None:
+        result = paginate_list(self.object_list, per_page=10)
+
+        assert len(result.object_list) == 10
+
+    def test_default_page_number(self) -> None:
+        result = paginate_list(self.object_list)
+
+        assert result.number == 1
+
+    def test_default_per_page(self) -> None:
+        result = paginate_list(self.object_list)
+
+        assert len(result.object_list) == 50
+
+    def test_empty_list(self) -> None:
+        result = paginate_list([])
+
+        assert len(result.object_list) == 0
+
+    def test_has_next_page(self) -> None:
+        result = paginate_list(self.object_list, page_number=1)
+
+        assert result.has_next() is True
+
+    def test_has_previous_page(self) -> None:
+        result = paginate_list(self.object_list, page_number=2)
+
+        assert result.has_previous() is True
+
+    def test_last_page_has_no_next(self) -> None:
+        result = paginate_list(self.object_list, page_number=2)
+
+        assert result.has_next() is False
+
+    def test_page_number_exceeds_pages_returns_last_page(self) -> None:
+        result = paginate_list(self.object_list, page_number=999)
+
+        assert result.number == 2
+
+    def test_returns_page_object(self) -> None:
+        result = paginate_list(self.object_list)
+
+        assert isinstance(result, Page)
+
+
+class TestPaginationUrl(TestCase):
+    def setUp(self) -> None:
+        self.factory = RequestFactory()
+
+    def _create_context(self, request) -> MagicMock:
+        context = MagicMock()
+        context.request = request
+        return context
+
+    def test_custom_page_name(self) -> None:
+        request = self.factory.get('/')
+        context = self._create_context(request)
+
+        result = pagination_url(context, page_number=2, page_name='p')
+
+        assert 'p=2' in result
+
+    def test_default_page_name(self) -> None:
+        request = self.factory.get('/')
+        context = self._create_context(request)
+
+        result = pagination_url(context, page_number=1)
+
+        assert 'page=1' in result
+
+    def test_multiple_query_params(self) -> None:
+        request = self.factory.get('/', {'filter': 'active', 'sort': 'name'})
+        context = self._create_context(request)
+
+        result = pagination_url(context, page_number=3)
+
+        assert 'page=3' in result
+        assert 'filter=active' in result
+        assert 'sort=name' in result
+
+    def test_preserves_existing_query_params(self) -> None:
+        request = self.factory.get('/', {'search': 'test'})
+        context = self._create_context(request)
+
+        result = pagination_url(context, page_number=2)
+
+        assert 'search=test' in result
+        assert 'page=2' in result
+
+    def test_replaces_space_with_plus(self) -> None:
+        request = self.factory.get('/', {'search': 'hello world'})
+        context = self._create_context(request)
+
+        result = pagination_url(context, page_number=1)
+
+        assert 'search=hello+world' in result
+
+    def test_returns_query_string(self) -> None:
+        request = self.factory.get('/')
+        context = self._create_context(request)
+
+        result = pagination_url(context, page_number=1)
+
+        assert result.startswith('?')
+
+
+class TestGetElidedPageRange(TestCase):
+    def test_custom_on_each_side(self) -> None:
+        page_obj = MagicMock()
+        page_obj.number = 5
+        page_obj.paginator.get_elided_page_range.return_value = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+        get_elided_page_range(page_obj, on_each_side=3)
+
+        page_obj.paginator.get_elided_page_range.assert_called_once_with(
+            number=5,
+            on_each_side=3,
+            on_ends=2
+        )
+
+    def test_custom_on_ends(self) -> None:
+        page_obj = MagicMock()
+        page_obj.number = 5
+        page_obj.paginator.get_elided_page_range.return_value = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+        get_elided_page_range(page_obj, on_ends=3)
+
+        page_obj.paginator.get_elided_page_range.assert_called_once_with(
+            number=5,
+            on_each_side=2,
+            on_ends=3
+        )
+
+    def test_default_parameters(self) -> None:
+        page_obj = MagicMock()
+        page_obj.number = 1
+        page_obj.paginator.get_elided_page_range.return_value = [1, 2, 3]
+
+        get_elided_page_range(page_obj)
+
+        page_obj.paginator.get_elided_page_range.assert_called_once_with(
+            number=1,
+            on_each_side=2,
+            on_ends=2
+        )
+
+    def test_returns_elided_page_range(self) -> None:
+        page_obj = MagicMock()
+        page_obj.number = 1
+        expected_range = [1, 2, 3, '...', 10]
+        page_obj.paginator.get_elided_page_range.return_value = expected_range
+
+        result = get_elided_page_range(page_obj)
+
+        assert result == expected_range

django_spire/contrib/performance/decorators.py

@@ -1,21 +1,31 @@
+from __future__ import annotations
+
 import logging
 import time
 
+from typing import Callable, ParamSpec, TypeVar
+
 from django.conf import settings
 
 
-def performance_timer(func):
-    def wrapper(*args, **kwargs):
+P = ParamSpec('P')
+R = TypeVar('R')
+
+log = logging.getLogger(__name__)
+
+
+def performance_timer(func: Callable[P, R]) -> Callable[P, R]:
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
         if settings.DEBUG:
             start_time = time.perf_counter()
             result = func(*args, **kwargs)
             end_time = time.perf_counter()
 
-            logging.warning(f'{end_time - start_time:.4f} seconds runtime for "{func.__module__}.{func.__qualname__}"')
+            message = f'{end_time - start_time:.4f} seconds runtime for "{func.__module__}.{func.__qualname__}"'
+            log.warning(message)
 
             return result
 
-        else:
-            return func(*args, **kwargs)
+        return func(*args, **kwargs)
 
-    return wrapper
+    return wrapper

django_spire/contrib/performance/tests/test_performance.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from unittest.mock import patch
+
+from django.test import TestCase, override_settings
+
+from django_spire.contrib.performance.decorators import performance_timer
+
+
+class TestPerformanceTimer(TestCase):
+    @override_settings(DEBUG=True)
+    def test_calls_function_when_debug_true(self) -> None:
+        @performance_timer
+        def sample_func() -> str:
+            return 'result'
+
+        result = sample_func()
+
+        assert result == 'result'
+
+    @override_settings(DEBUG=False)
+    def test_calls_function_when_debug_false(self) -> None:
+        @performance_timer
+        def sample_func() -> str:
+            return 'result'
+
+        result = sample_func()
+
+        assert result == 'result'
+
+    @override_settings(DEBUG=True)
+    def test_logs_warning_when_debug_true(self) -> None:
+        @performance_timer
+        def sample_func() -> str:
+            return 'result'
+
+        with patch('django_spire.contrib.performance.decorators.log.warning') as mock_warning:
+            sample_func()
+
+            mock_warning.assert_called_once()
+
+    @override_settings(DEBUG=False)
+    def test_no_logging_when_debug_false(self) -> None:
+        @performance_timer
+        def sample_func() -> str:
+            return 'result'
+
+        with patch('django_spire.contrib.performance.decorators.log.warning') as mock_warning:
+            sample_func()
+
+            mock_warning.assert_not_called()
+
+    @override_settings(DEBUG=True)
+    def test_log_message_contains_runtime(self) -> None:
+        @performance_timer
+        def sample_func() -> str:
+            return 'result'
+
+        with patch('django_spire.contrib.performance.decorators.log.warning') as mock_warning:
+            sample_func()
+
+            log_message = mock_warning.call_args[0][0]
+
+            assert 'seconds runtime' in log_message
+
+    @override_settings(DEBUG=True)
+    def test_log_message_contains_function_name(self) -> None:
+        @performance_timer
+        def sample_func() -> str:
+            return 'result'
+
+        with patch('django_spire.contrib.performance.decorators.log.warning') as mock_warning:
+            sample_func()
+
+            log_message = mock_warning.call_args[0][0]
+
+            assert 'sample_func' in log_message
+
+    @override_settings(DEBUG=True)
+    def test_passes_args_to_function(self) -> None:
+        @performance_timer
+        def sample_func(a: int, b: int) -> int:
+            return a + b
+
+        result = sample_func(2, 3)
+
+        assert result == 5
+
+    @override_settings(DEBUG=True)
+    def test_passes_kwargs_to_function(self) -> None:
+        @performance_timer
+        def sample_func(a: int, b: int = 10) -> int:
+            return a + b
+
+        result = sample_func(5, b=20)
+
+        assert result == 25
+
+    @override_settings(DEBUG=True)
+    def test_returns_none_when_function_returns_none(self) -> None:
+        @performance_timer
+        def sample_func() -> None:
+            pass
+
+        result = sample_func()
+
+        assert result is None

django_spire/contrib/progress/__init__.py

@@ -4,7 +4,6 @@ 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__ = [
@@ -16,6 +15,5 @@ __all__ = [
     'TaskProgressUpdater',
     'TaskResult',
     'TaskState',
-    'TrackerState',
-    'sse_stream_view',
+    'TrackerState'
 ]

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

@@ -1,15 +1,16 @@
 class ProgressStream {
     constructor(url, config = {}) {
         this.url = url;
-        this.controller = null;
         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,
-            redirect_delay: config.redirect_delay || 1000
+            redirect_delay: config.redirect_delay || 1000,
+            poll_interval: config.poll_interval || 1000
         };
     }
 
@@ -17,19 +18,7 @@ class ProgressStream {
         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);
-        }
+        this._start_polling();
     }
 
     stop() {
@@ -37,86 +26,53 @@ class ProgressStream {
 
         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);
+        if (this.poll_interval) {
+            clearInterval(this.poll_interval);
+            this.poll_interval = null;
         }
     }
 
-    _process_buffer(buffer) {
-        let lines = buffer.split('\n');
-        let remainder = lines.pop();
+    _start_polling() {
+        this._poll();
 
-        for (let line of lines) {
-            if (line.startsWith('data: ')) {
-                this._handle_message(line.slice(6));
+        this.poll_interval = setInterval(() => {
+            if (this.is_running) {
+                this._poll();
             }
-        }
-
-        return remainder;
+        }, this.config.poll_interval);
     }
 
-    _handle_message(json_string) {
-        let data;
-
+    async _poll() {
         try {
-            data = JSON.parse(json_string);
-        } catch {
-            return;
-        }
+            let response = await fetch(this.url, {
+                method: 'POST',
+                headers: {
+                    'X-CSRFToken': get_cookie('csrftoken'),
+                }
+            });
 
-        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();
-        }
-    }
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
 
-    _handle_error(error) {
-        if (error.name === 'AbortError') return;
+            let data = await response.json();
 
-        console.error('ProgressStream error:', error);
+            this.config.on_update(data);
 
-        this.config.on_error({
-            step: 'error',
-            message: 'Connection error',
-            progress: 0
-        });
+            if (data.step === 'error') {
+                this.config.on_error(data);
+                this.stop();
+                return;
+            }
 
-        this.stop();
+            if (data.progress >= 100) {
+                this.config.on_complete(data);
+                this.stop();
+                this._redirect();
+            }
+        } catch (error) {
+            console.warn('Poll error:', error.message);
+        }
     }
 
     _redirect() {

django_spire/contrib/queryset/enums.py

@@ -1,6 +1,8 @@
+from __future__ import annotations
+
 from enum import StrEnum
 
 
 class SessionFilterActionEnum(StrEnum):
     CLEAR = 'Clear'
-    FILTER = 'Filter'
+    FILTER = 'Filter'

django_spire/contrib/queryset/filter_tools.py

@@ -1,13 +1,16 @@
 from __future__ import annotations
 
-from django.db.models import QuerySet
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from django.db.models import QuerySet
 
 
 def filter_by_lookup_map(
-        queryset: QuerySet,
-        lookup_map: dict,
-        data: dict,
-        extra_filters: dict | None = None
+    queryset: QuerySet,
+    lookup_map: dict,
+    data: dict,
+    extra_filters: dict | None = None
 ):
     """
     Filters a given queryset based on a lookup map and provided data. Additional filters
@@ -23,7 +26,9 @@ def filter_by_lookup_map(
 
     Returns:
         QuerySet: The filtered queryset.
+
     """
+
     if extra_filters is None:
         extra_filters = {}
 

django_spire/contrib/queryset/mixins.py

@@ -1,25 +1,27 @@
 from __future__ import annotations
 
 import json
+
 from abc import abstractmethod
-from typing import Type
+from typing import TYPE_CHECKING
 
-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
 
+if TYPE_CHECKING:
+    from django.core.handlers.wsgi import WSGIRequest
+    from django.forms import Form
 
-class SessionFilterQuerySetMixin(QuerySet):
 
+class SessionFilterQuerySetMixin(QuerySet):
     def process_session_filter(
-            self,
-            request: WSGIRequest,
-            session_key: str,
-            form_class: Type[Form],
-            is_from_body: bool = False,
+        self,
+        request: WSGIRequest,
+        session_key: str,
+        form_class: type[Form],
+        is_from_body: bool = False
     ) -> QuerySet:
         # Session keys must match to process new queryset data
 
@@ -41,10 +43,9 @@ class SessionFilterQuerySetMixin(QuerySet):
 
             # Apply filters when the user submits the filter form
             if (
-                    action == SessionFilterActionEnum.FILTER
-                    and session_key == data.get('session_filter_key')
+                action == SessionFilterActionEnum.FILTER
+                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,9 +57,9 @@ class SessionFilterQuerySetMixin(QuerySet):
             # When no new filter data is applied and session is NOT yet expired,
             # return the original queryset
             return self.bulk_filter(session.data)
-        else:
-            show_form_errors(request, form)
-            return self
+
+        show_form_errors(request, form)
+        return self
 
     @abstractmethod
     def bulk_filter(self, filter_data: dict) -> QuerySet:
@@ -66,7 +67,6 @@ class SessionFilterQuerySetMixin(QuerySet):
 
 
 class SearchQuerySetMixin(QuerySet):
-
     @abstractmethod
     def search(self, value: str | None) -> QuerySet:
         pass