django-spire 0.23.4__py3-none-any.whl

django_spire/contrib/options/mixins.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from django.db import models
+from django_spire.contrib.options.options import Options
+
+DEFAULT_OPTIONS = Options(sections=[])
+
+
+class OptionsModelMixin(models.Model):
+    _options = models.JSONField(default=dict)
+    _default_options = DEFAULT_OPTIONS
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.options = Options.load_dict(self._options)
+
+    def _sync_options(self):
+        if self.options != self._default_options:
+            self.options.sync_options(self._default_options)
+            self._options = self.options.to_dict()
+
+    def get_option(self, section_name: str, option_key: str):
+        self._sync_options()
+        return self.options.get_setting(section_name, option_key)
+
+    def update_session(self, request):
+        request.session['user_options'] = self.options.to_dict()
+
+    def update_option(
+            self,
+            section_name: str,
+            option_key: str,
+            value: str | bool | int,
+            commit=True
+    ):
+        self._sync_options()
+        self.options.update_setting(section_name, option_key, value)
+        self._options = self.options.to_dict()
+
+        if commit:
+            self.save()
+
+    class Meta:
+        abstract = True

django_spire/contrib/options/options.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Option:
+    key: str
+    value: str | bool | int
+
+
+@dataclass
+class OptionSection:
+    name: str
+    options: list[Option] = field(default_factory=list)
+
+    def __eq__(self, other):
+        return self.to_dict() == other.to_dict()
+
+    def __contains__(self, option_key: str) -> bool:
+        return any(option.key == option_key for option in self.options)
+
+    def __getitem__(self, option_key: str) -> Option:
+        for option in self.options:
+            if option.key.lower() == option_key.lower():
+                return option
+
+        message = f'Option "{option_key}" not found'
+        raise KeyError(message)
+
+    def to_dict(self):
+        section_dict = {}
+
+        for option in self.options:
+            section_dict[option.key.lower()] = option.value
+
+        return section_dict
+
+
+@dataclass
+class Options:
+    sections: list[OptionSection] = field(default=list)
+
+    def __eq__(self, other):
+        # Compares the section names and option keys to sync options.
+        section_names = sorted([section.name.lower() for section in self.sections])
+        other_section_names = sorted([section.name.lower() for section in other.sections])
+
+        if section_names != other_section_names:
+            return False
+
+        for section in self.sections:
+            option_keys = sorted([option.key.lower() for option in section.options])
+            other_option_keys = sorted([option.key.lower() for option in other[section.name].options])
+
+            if option_keys != other_option_keys:
+                return False
+
+        return True
+
+    def __contains__(self, section_name: str) -> bool:
+        return any(section.name == section_name for section in self.sections)
+
+    def __getitem__(self, section_name: str) -> OptionSection:
+        for section in self.sections:
+            if section.name.lower() == section_name.lower():
+                return section
+
+        message = f'Section "{section_name}" not found'
+        raise KeyError(message)
+
+    @classmethod
+    def load_dict(cls, options_dict: dict):
+        sections = []
+
+        for section_name, section_options in options_dict.items():
+            options = []
+
+            for option_key, option_value in section_options.items():
+                options.append(Option(key=option_key, value=option_value))
+
+            sections.append(OptionSection(name=section_name, options=options))
+
+        return cls(sections=sections)
+
+    def get_setting(self, section_name: str, option_key: str):
+        return self[section_name][option_key].value
+
+    def sync_options(self, default_options: 'Options'):
+        new_sections = []
+        for section in default_options.sections:
+            new_section = OptionSection(name=section.name)
+
+            for option in section.options:
+                key = option.key
+                if section.name in self and key in self[section.name]:
+                    value = self[section.name][key].value
+                else:
+                    value = option.value
+
+                new_section.options.append(Option(key=key, value=value))
+
+            new_sections.append(new_section)
+
+        self.sections = new_sections
+
+    def update_setting(self, section_name: str, option_key: str, value: str | bool):
+        self[section_name][option_key].value = value
+
+    def to_dict(self):
+        options_dict = {}
+
+        for section in self.sections:
+            options_dict[section.name.lower()] = section.to_dict()
+
+        return options_dict

django_spire/contrib/options/tests/factories.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from django_spire.contrib.options.mixins import OptionsModelMixin
+from django_spire.contrib.options.options import Options, Option, OptionSection
+from django_spire.auth.user.tests.factories import create_user
+
+
+def create_test_options() -> Options:
+    # Test option to match test dict for testing
+    return Options(sections=[
+        OptionSection(
+            name='notification',
+            options=[
+                Option('email', True),
+                Option('push', False),
+            ]
+        ),
+        OptionSection(
+            name='system',
+            options=[
+                Option('timezone', 'America/Edmonton'),
+            ]
+        ),
+    ])
+
+
+def create_test_options_dict() -> dict:
+    return {
+        'notification': {
+            'email': True,
+            'push': False
+        },
+        'system': {
+            'timezone': 'America/Edmonton'
+        }
+    }
+
+
+def create_test_option_section() -> OptionSection:
+    return OptionSection(
+        name='notification',
+        options=[
+            Option('email', True),
+            Option('push', False),
+        ]
+    )
+
+
+def create_test_option() -> Option:
+    return Option('email', True)
+
+
+def create_test_options_mixin() -> OptionsModelMixin:
+    user = create_user('Joe', 'goatery_99')
+    profile = user.profile
+    profile._default_options = create_test_options()
+    profile.options = create_test_options()
+    profile._options = profile.options.to_dict()
+    return profile
+

django_spire/contrib/options/tests/test_unit.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class OptionsUnitTestCase(BaseTestCase):
+    pass
+
+    # def test_option_get_settings(self):
+    #     options = factories.create_test_options()
+    #     self.assertEqual(options.get_setting('notification', 'push'), False)
+
+    # def test_option_contains(self):
+    #     options = factories.create_test_options()
+    #     self.assertTrue('notification' in options)
+
+    # def test_option_equal_true(self):
+    #     self.assertEqual(factories.create_test_options(), factories.create_test_options())
+
+    # def test_option_section_equal_false(self):
+    #     options = factories.create_test_options()
+    #     other_options = Options.load_dict({
+    #         'General': {'volume': 10},
+    #         'Notifications': {'email': True}
+    #     })
+    #     self.assertTrue(options != other_options)
+
+    # def test_option_values_equal_false(self):
+    #     options = Options.load_dict({
+    #         'General': {'volume': 10, 'language': 'en'},
+    #         'Notifications': {'email': True}
+    #     })
+    #     other_options = Options.load_dict({
+    #         'General': {'volume': 10},
+    #         'Notifications': {'email': True}
+    #     })
+    #     self.assertTrue(options != other_options)
+
+    # def test_option_getitem(self):
+    #     options = factories.create_test_options()
+    #     self.assertEqual(type(options['notification']), OptionSection)
+    #     self.assertEqual(type(options['notification']['push']), Option)
+    #     self.assertEqual(options['notification']['push'].value, False)
+
+    # def test_option_getitem_key_error(self):
+    #     options = factories.create_test_options()
+    #     with self.assertRaises(KeyError):
+    #         options['invalid']
+
+    # def test_option_load_dict(self):
+    #     options = Options.load_dict(factories.create_test_options_dict())
+    #     self.assertEqual(options.get_setting('notification', 'push'), False)
+    #     self.assertTrue('notification' in options)
+
+    # def test_option_update_setting(self):
+    #     options = factories.create_test_options()
+    #     options.update_setting('notification', 'push', True)
+    #     self.assertEqual(options.get_setting('notification', 'push'), True)
+
+    # def test_option_to_dict(self):
+    #     options = factories.create_test_options()
+    #     options_dict = factories.create_test_options_dict()
+    #     self.assertEqual(options.to_dict(), options_dict)
+
+    # def test_option_sync_options(self):
+    #     original_options = Options.load_dict({
+    #         'General': {'volume': 10},
+    #         'Notifications': {'email': True}
+    #     })
+    #     new_structure = Options.load_dict({
+    #         'General': {'volume': 5, 'brightness': 70},
+    #         'Notifications': {'email': False, 'push': True},
+    #         'Privacy': {'location': False}
+    #     })
+    #     original_options.sync_options(new_structure)
+
+    #     # Check if the original value is preserved and new settings are added
+    #     self.assertEqual(original_options.get_setting('General', 'volume'), 10)
+    #     self.assertTrue('brightness' in original_options['General'])
+    #     self.assertTrue('push' in original_options['Notifications'])
+    #     self.assertTrue('Privacy' in original_options)
+
+
+class OptionsSectionUnitTestCase(BaseTestCase):
+    pass
+
+    # def test_option_section_equal(self):
+    #     self.assertEqual(factories.create_test_option_section(), factories.create_test_option_section())
+
+    # def test_option_section_contains(self):
+    #     section = factories.create_test_option_section()
+    #     self.assertTrue('email' in section)
+
+    # def test_option_section_getitem(self):
+    #     section = factories.create_test_option_section()
+    #     self.assertEqual(type(section['email']), Option)
+    #     self.assertEqual(section['email'].value, True)
+
+    # def test_option_section_getitem_key_error(self):
+    #     section = factories.create_test_option_section()
+    #     with self.assertRaises(KeyError):
+    #         section['invalid']
+
+    # def test_option_section_to_dict(self):
+    #     section = OptionSection(
+    #         name='notification',
+    #         options=[
+    #             Option('email', True),
+    #             Option('push', False),
+    #         ]
+    #     )
+    #     section_dict = {
+    #         'email': True,
+    #         'push': False
+    #     }
+    #     self.assertEqual(section.to_dict(), section_dict)
+
+
+class OptionUnitTestCase(BaseTestCase):
+    pass
+
+    # def test_option_init(self):
+    #     option = Option('email', True)
+    #     self.assertEqual(option.key, 'email')
+    #     self.assertEqual(option.value, True)
+
+
+class OptionMixinUnitTestCase(BaseTestCase):
+    pass
+
+    # def test_mixin_get_option(self):
+    #     mixin = factories.create_test_options_mixin()
+    #     self.assertEqual(mixin.get_option('notification', 'email'), True)
+
+    # def test_mixin_update_option(self):
+    #     mixin = factories.create_test_options_mixin()
+    #     mixin.update_option('notification', 'email', False, commit=False)
+    #     self.assertEqual(mixin.get_option('notification', 'email'), False)
+    #     self.assertEqual(mixin._options, mixin.options.to_dict())
+
+    # def test_mixin_update_session(self):
+    #     mixin = factories.create_test_options_mixin()
+    #     request = RequestFactory()
+    #     request.session = {}
+    #     mixin.update_session(request)
+    #     self.assertEqual(request.session['user_options'], mixin.options.to_dict())
+
+

django_spire/contrib/ordering/exceptions.py

@@ -0,0 +1,5 @@
+class OrderingMixinExceptionGroup(Exception):
+    pass
+
+class OrderingMixinException(Exception):
+    pass

django_spire/contrib/ordering/mixins.py

@@ -0,0 +1,14 @@
+from django.db import models
+
+from django_spire.contrib.ordering.services.service import OrderingService
+
+
+class OrderingModelMixin(models.Model):
+    order = models.PositiveIntegerField(
+        default=0
+    )
+
+    ordering_services = OrderingService()
+
+    class Meta:
+        abstract = True

django_spire/contrib/ordering/querysets.py

@@ -0,0 +1,5 @@
+from django.db.models import QuerySet, F
+
+
+class OrderingQuerySetMixin(QuerySet):
+    pass

django_spire/contrib/ordering/services/processor_service.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from django_spire.contrib.ordering.exceptions import OrderingMixinExceptionGroup
+from django_spire.contrib.ordering.validators import OrderingMixinValidator
+from django_spire.contrib.service import BaseDjangoModelService
+
+if TYPE_CHECKING:
+    from django.db.models import Model, QuerySet
+    from django_spire.contrib.ordering.mixins import OrderingModelMixin
+
+
+class OrderingProcessorService(BaseDjangoModelService['OrderingModelMixin']):
+    obj: OrderingModelMixin
+
+    def _reorder_objects(self, objects: QuerySet[Model]):
+        for index, item in enumerate(objects):
+            item.order = index
+
+        self.obj_class.objects.bulk_update(objects, ['order'])
+
+    def _reorder_destination_and_origin_objects(
+        self,
+        destination_objects: QuerySet[Model],
+        origin_objects: QuerySet[Model],
+        insert_position: int,
+    ):
+        self._reorder_objects(origin_objects)
+
+        # Forces destination objects to refresh in the event they overlap the origin objects
+        destination_objects = destination_objects.all().order_by('order')
+
+        for index, item in enumerate(destination_objects):
+            if item.order >= insert_position:
+                item.order = index + 1
+
+        self.obj_class.objects.bulk_update(destination_objects, ['order'])
+
+    def move_to_position(
+        self,
+        destination_objects: QuerySet[Model],
+        position: int,
+        origin_objects: QuerySet[Model] = None,
+    ):
+        # If origin objects not passed, assume origin objects are same as destination
+        if origin_objects is None:
+            origin_objects = destination_objects
+
+        ordering_mixin_validator = OrderingMixinValidator(
+            destination_objects=destination_objects,
+            position=position,
+            obj=self.obj,
+            origin_objects=origin_objects,
+        )
+
+        if not ordering_mixin_validator.validate():
+            raise OrderingMixinExceptionGroup(
+                'Ordering validation failed.',
+                ordering_mixin_validator.errors
+            )
+
+        destination_objects = destination_objects.exclude(pk=self.obj.pk).order_by('order')
+        origin_objects = origin_objects.exclude(pk=self.obj.pk).order_by('order')
+
+        self._reorder_destination_and_origin_objects(
+            destination_objects=destination_objects,
+            origin_objects=origin_objects,
+            insert_position=position,
+        )
+
+        self.obj.order = position
+        self.obj.save(update_fields=['order'])
+
+    def remove_from_objects(
+        self,
+        destination_objects: QuerySet[Model],
+    ):
+        ordering_mixin_validator = OrderingMixinValidator(
+            destination_objects=destination_objects,
+            position=0,
+            obj=self.obj,
+            origin_objects=destination_objects,
+        )
+
+        if not ordering_mixin_validator.validate():
+            raise ExceptionGroup(
+                'Ordering validation failed.',
+                ordering_mixin_validator.errors
+            )
+
+        destination_objects = destination_objects.exclude(pk=self.obj.pk).order_by('order')
+
+        self._reorder_objects(objects=destination_objects)

django_spire/contrib/ordering/services/service.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from django_spire.contrib.ordering.services.processor_service import \
+    OrderingProcessorService
+from django_spire.contrib.service import BaseDjangoModelService
+
+if TYPE_CHECKING:
+    from django_spire.contrib.ordering.mixins import OrderingModelMixin
+
+
+class OrderingService(BaseDjangoModelService['OrderingModelMixin']):
+    obj: OrderingModelMixin
+
+    processor = OrderingProcessorService()

django_spire/contrib/ordering/validators.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from django_spire.contrib.ordering.exceptions import OrderingMixinException
+
+if TYPE_CHECKING:
+    from django.db.models import Model, QuerySet
+
+
+class OrderingMixinValidator:
+    def __init__(
+        self,
+        destination_objects: QuerySet[Model],
+        position: int,
+        obj: Model,
+        origin_objects: QuerySet[Model],
+    ):
+        self._destination_objects = destination_objects
+        self._position = position
+        self._origin_objects = origin_objects
+        self._obj = obj
+
+        self._errors: list[OrderingMixinException] = []
+
+    @property
+    def errors(self) -> list[OrderingMixinException]:
+        """Returns list of OrderingMixinException errors."""
+        return self._errors
+
+    def validate(self) -> bool:
+        """
+        Validates that the destination and origin and insertion objects and position are valid.
+        Returns tuple of validity and applicable error messages.
+        """
+
+        self._validate_position()
+        return not self._errors
+
+    def _validate_position(self):
+        """Ensure position is valid."""
+        if self._position < 0 or not isinstance(self._position, int):
+            self._errors.append(OrderingMixinException('Position must be a positive number.'))
+
+        if self._position > len(self._destination_objects):
+            self._errors.append(OrderingMixinException('Position must be less than the number of destination objects.'))

django_spire/contrib/pagination/pagination.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from django.core.paginator import Paginator, Page
+
+
+def paginate_list(
+    object_list: list,
+    page_number: int = 1,
+    per_page: int = 50
+) -> Page:
+    paginator = Paginator(object_list, per_page)
+    return paginator.get_page(page_number)

django_spire/contrib/pagination/templatetags/pagination_tags.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from django import template
+
+
+register = template.Library()
+
+
+@register.simple_tag(takes_context=True)
+def pagination_url(
+    context,
+    page_number: int,
+    page_name: str = 'page',
+    **kwargs
+):
+    updated_context = context.request.GET.copy()
+    updated_context[page_name] = page_number
+    query_string = '?'
+
+    for index, query_param in enumerate(updated_context):
+        query_param_value = updated_context[query_param]
+        if isinstance(query_param_value, str):
+            # Replacing space with + sign to match how query parameters and django form filtering.
+            query_param_value = query_param_value.replace(' ', '+')
+
+        if index == 0:
+            query_string = query_string + f'{query_param}={query_param_value}'
+        else:
+            query_string = query_string + f'&{query_param}={query_param_value}'
+
+    return query_string
+
+
+@register.simple_tag
+def get_elided_page_range(
+    page_obj,
+    on_each_side: int = 2,
+    on_ends: int = 2
+):
+    return page_obj.paginator.get_elided_page_range(
+        number=page_obj.number,
+        on_each_side=on_each_side,
+        on_ends=on_ends
+    )

django_spire/contrib/performance/decorators.py

@@ -0,0 +1,21 @@
+import logging
+import time
+
+from django.conf import settings
+
+
+def performance_timer(func):
+    def wrapper(*args, **kwargs):
+        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__}"')
+
+            return result
+
+        else:
+            return func(*args, **kwargs)
+
+    return wrapper

django_spire/contrib/progress/__init__.py

@@ -0,0 +1,10 @@
+from django_spire.contrib.progress.mixins import ProgressTrackingMixin
+from django_spire.contrib.progress.tracker import ProgressTracker
+from django_spire.contrib.progress.views import sse_stream_view
+
+
+__all__ = [
+    'ProgressTracker',
+    'ProgressTrackingMixin',
+    'sse_stream_view',
+]