django-spire 0.23.4__py3-none-any.whl

django_spire/contrib/session/controller.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime, timedelta
+from typing import Any
+
+from django.core.serializers.json import DjangoJSONEncoder
+from django.http import HttpRequest
+
+
+class SessionController:
+    """
+        This class provides an interface for storing, retrieving, and managing session data
+        with automatic expiration. It handles session data under a specific key and supports
+        timeout-based cleanup of expired sessions.
+
+        Args:
+            request (HttpRequest): The Django request object containing the session.
+            session_key (str): Unique key under which the session data will be stored.
+            seconds_till_expiry (int, optional): Number of seconds until session expiry.
+                Defaults to 300 seconds (5 minutes).
+    """
+
+    _TIMEOUT_KEY = '_timeout_datestamp'
+
+    def __init__(
+            self,
+            request: HttpRequest,
+            session_key: str,
+            seconds_till_expiry: int = 60 * 5
+    ):
+        self.request = request
+        self.session_key = session_key
+        self.seconds_till_expiry = seconds_till_expiry
+
+        self.request.session.setdefault(self.session_key, dict())
+        self._session = self.request.session[self.session_key]
+
+        self._clean()
+
+    def __getitem__(self, key: str) -> Any:
+        return self.data[key]
+
+    def __setitem__(self, key: str, value: Any):
+        self.add_data(key, value)
+
+    def add_data(self, key: str, data: Any):
+        self._session[key] = data
+        self._set_timeout_datestamp()
+        self._set_modified()
+
+    @property
+    def data(self):
+        return self._session
+
+    @property
+    def is_expired(self) -> bool:
+        current_timestamp = datetime.now().timestamp()
+        return self.timeout_datestamp < current_timestamp
+
+    @property
+    def timeout_datestamp(self) -> float:
+        return self.data.get(self._TIMEOUT_KEY, 0)
+
+    def remove_data(self, key: str):
+        self.data.pop(key)
+        self._set_modified()
+
+        # remove the session completely if there is no data in it.
+        if self._TIMEOUT_KEY in self.data and len(self.data.keys()) == 1:
+            self.data.pop(self._TIMEOUT_KEY)
+
+    def purge(self):
+        self.request.session.pop(self.session_key)
+        self._set_modified()
+
+    def _clean(self) -> None:
+        if self._TIMEOUT_KEY in self.data and self.is_expired:
+            self.request.session.pop(self.session_key)
+            self._set_modified()
+
+    def _set_modified(self):
+        self.request.session.modified = True
+
+    @property
+    def has_data(self) -> bool:
+        return bool(self.data)
+
+    def _set_timeout_datestamp(self):
+        timeout_datetime = datetime.now() + timedelta(seconds=self.seconds_till_expiry)
+        self.data[self._TIMEOUT_KEY] = timeout_datetime.timestamp()
+
+    def to_json(self):
+        return json.dumps(self.data, cls=DjangoJSONEncoder)

django_spire/contrib/session/templatetags/session_tags.py

@@ -0,0 +1,15 @@
+from django import template
+from django.utils.html import escapejs
+from django.utils.safestring import mark_safe
+
+from django_spire.contrib.session.controller import SessionController
+
+register = template.Library()
+
+
+@register.simple_tag(takes_context=True)
+def session_controller_to_json(context, key):
+    request = context.get("request")
+    controller = SessionController(request, key)
+    data = controller.to_json()
+    return mark_safe(escapejs(data))

django_spire/contrib/session/tests/test_session_controller.py

@@ -0,0 +1,105 @@
+from datetime import datetime
+
+from django.test import TestCase, RequestFactory
+from django.contrib.sessions.middleware import SessionMiddleware
+from django.contrib.sessions.models import Session
+
+from django_spire.contrib.session.controller import SessionController
+
+
+class BaseSessionTestCase(TestCase):
+    def setUp(self):
+        self.factory = RequestFactory()
+        self.request = self.factory.get('/')
+
+        # Attach real session
+        middleware = SessionMiddleware(lambda req: None)
+        middleware.process_request(self.request)
+
+        self.shopping_cart_session = SessionController(
+            request=self.request,
+            session_key='shopping_cart'
+        )
+
+    def test_base_session_add_data(self):
+        key = 'currency'
+        value = 'CAD'
+
+        self.shopping_cart_session.add_data(key, value)
+        self.assertIn(key, self.shopping_cart_session.data)
+        self.assertEqual(self.shopping_cart_session.data[key], value)
+
+    def test_base_session_set_item(self):
+        key = 'currency'
+        value = 'CAD'
+
+        self.shopping_cart_session[key] = value
+        self.assertIn(key, self.shopping_cart_session.data)
+        self.assertEqual(self.shopping_cart_session.data[key], value)
+
+    def test_base_session_remove_data(self):
+        self.shopping_cart_session.add_data('currency', 'CAD')
+        self.shopping_cart_session.add_data('discount', None)
+        self.shopping_cart_session.remove_data('currency')
+
+        self.assertNotIn('currency', self.shopping_cart_session.data)
+        self.assertIn('discount', self.shopping_cart_session.data)
+
+    def test_set_session_modified(self):
+        self.shopping_cart_session.add_data('currency', 'CAD')
+        self.assertTrue(self.request.session.modified)
+
+    def test_session_has_data(self):
+        self.assertFalse(self.shopping_cart_session.has_data)
+
+        self.shopping_cart_session.add_data('currency', 'CAD')
+        self.assertTrue(self.shopping_cart_session.has_data)
+
+
+        self.shopping_cart_session.remove_data('currency')
+        self.assertFalse(self.shopping_cart_session.has_data)
+
+    def test_session_data_to_json(self):
+        self.shopping_cart_session.add_data('currency', 'CAD')
+        self.shopping_cart_session.add_data('discount', None)
+
+        self.assertTrue(isinstance(self.shopping_cart_session.to_json(), str))
+
+    # def test_to_json_errors_when_not_json_serializable(self):
+    #     self.shopping_cart_session.json_serializable = False
+    #
+    #     with self.assertRaises(ValueError):
+    #         self.shopping_cart_session.to_json()
+
+    def test_set_timeout_datestamp(self):
+        self.shopping_cart_session._set_timeout_datestamp()
+        self.assertIn('_timeout_datestamp', self.shopping_cart_session.data)
+        self.assertTrue(datetime.now().timestamp() < self.shopping_cart_session['_timeout_datestamp'])
+
+    def test_session_data_expiry(self):
+        self.shopping_cart_session.add_data('currency', 'CAD')
+        self.assertFalse(self.shopping_cart_session.is_expired)
+
+        self.shopping_cart_session.seconds_till_expiry = -5
+        self.shopping_cart_session._set_timeout_datestamp()
+        self.assertTrue(self.shopping_cart_session.is_expired)
+
+    def test_session_data_added_to_database(self):
+        # Add something to the session
+        self.shopping_cart_session.add_data('favorites', ['cool_shirt', 'fun_hat'] )
+        self.request.session.save()
+
+        # Get session from DB using session_key
+        session_key = self.request.session.session_key
+        session_in_db = Session.objects.get(session_key=session_key)
+
+        # Decode the session data
+        session_data = session_in_db.get_decoded()
+
+        self.assertIn(self.shopping_cart_session.session_key, session_data)
+        self.assertIn('favorites', session_data[self.shopping_cart_session.session_key])
+        self.assertEqual(
+            session_data[self.shopping_cart_session.session_key]['favorites'],
+            ['cool_shirt', 'fun_hat']
+        )
+

django_spire/contrib/utils.py

@@ -0,0 +1,2 @@
+def truncate_string(string: str, length: int) -> str:
+    return string[:(length - 3)] + '...' if len(string) > length else string

django_spire/core/apps.py

@@ -0,0 +1,10 @@
+from django.apps import AppConfig
+
+
+class DjangoSpireConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    label = 'django_spire_core'
+    name = 'django_spire.core'
+
+    URLPATTERNS_INCLUDE = 'django_spire.core.urls'
+    URLPATTERNS_NAMESPACE = 'core'

django_spire/core/context_processors.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from typing import Any, TYPE_CHECKING
+
+from django_spire.auth.controller.controller import AppAuthController
+from django_spire.conf import settings
+from django_spire.consts import __VERSION__
+from django_spire.theme.models import Theme
+from django_spire.theme.utils import get_theme_cookie_name
+
+if TYPE_CHECKING:
+    from django.core.handlers.wsgi import WSGIRequest
+
+
+def django_spire(request: WSGIRequest) -> dict[str, Any]:
+    auth_controller_dict = {}
+
+    for app_name in settings.DJANGO_SPIRE_AUTH_CONTROLLERS:
+        auth_controller_dict[app_name] = AppAuthController(app_name, request=request)
+
+    return {
+        'DJANGO_SPIRE_VERSION': __VERSION__,
+        'AuthController': auth_controller_dict
+    }
+
+
+def theme_context(request: WSGIRequest) -> dict[str, Any]:
+    default_string = getattr(
+        settings,
+        'DJANGO_SPIRE_DEFAULT_THEME',
+        'default-light'
+    )
+
+    default = Theme.from_string(
+        default_string,
+        default=Theme.get_default()
+    )
+
+    name = get_theme_cookie_name()
+    cookie = request.COOKIES.get(name, '')
+    theme = Theme.from_string(cookie, default=default)
+
+    path = getattr(
+        settings,
+        'DJANGO_SPIRE_THEME_PATH',
+        '/static/django_spire/css/themes/{family}/app-{mode}.css'
+    )
+
+    return {
+        'DJANGO_SPIRE_DEFAULT_THEME': default.value,
+        'DJANGO_SPIRE_THEME_COOKIE_NAME': name,
+        'DJANGO_SPIRE_THEME_PATH': path,
+        'theme': theme.to_dict(),
+    }

django_spire/core/converters/__init__.py

@@ -0,0 +1,7 @@
+from django_spire.core.converters.to_pydantic import django_to_pydantic_model
+from django_spire.core.converters.to_data import fake_model_field_value
+
+__all__ = [
+    "django_to_pydantic_model",
+    "fake_model_field_value"
+]

django_spire/core/converters/tests/test_to_enums.py

@@ -0,0 +1,75 @@
+from enum import Enum
+from unittest import TestCase
+
+from django_spire.core.converters.to_enums import django_choices_to_enums
+
+
+class TestDjangoChoicesToEnums(TestCase):
+
+    def test_basic_conversion(self):
+        """Test basic conversion with simple choices"""
+        choices = [
+            ('ACTIVE', 'Active'),
+            ('INACTIVE', 'Inactive'),
+            ('PENDING', 'Pending')
+        ]
+
+        ResultEnum = django_choices_to_enums('Status', choices)
+
+        # Check if enum is created correctly
+        self.assertTrue(issubclass(ResultEnum, Enum))
+        self.assertEqual(ResultEnum.__name__, 'Status')
+
+        # Check enum members
+        self.assertEqual(ResultEnum.ACTIVE.value, 'ACTIVE')
+        self.assertEqual(ResultEnum.INACTIVE.value, 'INACTIVE')
+        self.assertEqual(ResultEnum.PENDING.value, 'PENDING')
+
+        # Check number of members
+        self.assertEqual(len(ResultEnum), 3)
+
+    def test_empty_choices(self):
+        """Test function with empty choices list"""
+        choices = []
+        ResultEnum = django_choices_to_enums('EmptyStatus', choices)
+
+        self.assertTrue(issubclass(ResultEnum, Enum))
+        self.assertEqual(ResultEnum.__name__, 'EmptyStatus')
+        self.assertEqual(len(ResultEnum), 0)
+
+    def test_single_choice(self):
+        """Test with a single choice"""
+        choices = [('OPEN', 'Open')]
+        ResultEnum = django_choices_to_enums('SingleStatus', choices)
+
+        self.assertTrue(issubclass(ResultEnum, Enum))
+        self.assertEqual(ResultEnum.__name__, 'SingleStatus')
+        self.assertEqual(ResultEnum.OPEN.value, 'OPEN')
+        self.assertEqual(len(ResultEnum), 1)
+
+    def test_duplicate_keys(self):
+        """Test behavior with duplicate keys (should use last occurrence)"""
+        choices = [
+            ('STATUS', 'First'),
+            ('STATUS', 'Second')
+        ]
+        ResultEnum = django_choices_to_enums('DuplicateStatus', choices)
+
+        self.assertTrue(issubclass(ResultEnum, Enum))
+        self.assertEqual(ResultEnum.STATUS.value, 'STATUS')
+        self.assertEqual(len(ResultEnum), 1)
+
+    def test_different_key_value(self):
+        """Test when keys and values differ"""
+        choices = [
+            ('A', 'Alpha'),
+            ('B', 'Beta'),
+            ('G', 'Gamma')
+        ]
+        ResultEnum = django_choices_to_enums('Greek', choices)
+
+        self.assertTrue(issubclass(ResultEnum, Enum))
+        self.assertEqual(ResultEnum.A.value, 'A')
+        self.assertEqual(ResultEnum.B.value, 'B')
+        self.assertEqual(ResultEnum.G.value, 'G')
+        self.assertEqual(len(ResultEnum), 3)

django_spire/core/converters/tests/test_to_pydantic.py

@@ -0,0 +1,234 @@
+from unittest import TestCase
+from typing import get_origin, get_args, Union
+
+from pydantic import BaseModel
+
+from django.core.validators import MinValueValidator, MaxValueValidator
+from django.db import models
+import enum
+
+from django_spire.core.converters.to_pydantic import DjangoToPydanticFieldConverter, django_to_pydantic_model
+
+
+def is_optional(typ):
+    return get_origin(typ) is Union and type(None) in get_args(typ)
+
+
+class TestDjangoModelToPydanticModel(TestCase):
+    def test_comprehensive_model_conversion(self):
+        class ComprehensiveModel(models.Model):
+            # Django auto-adds an "id" primary key field.
+            char_field_with_choices = models.CharField(
+                max_length=10,
+                choices=[("A", "Active"), ("I", "Inactive")],
+                default="A",
+                help_text="Status of the item",
+                unique=True,
+                null=False
+            )
+            char_field_no_choices = models.CharField(
+                max_length=20,
+                default="default",
+                help_text="Description",
+                unique=False,
+                null=True
+            )
+            int_field = models.IntegerField(
+                validators=[MinValueValidator(0), MaxValueValidator(100)],
+                default=50,
+                help_text="Count",
+                unique=False,
+                null=True
+            )
+            decimal_field = models.DecimalField(
+                max_digits=5,
+                decimal_places=2,
+                default=0.0,
+                help_text="Price",
+                unique=False,
+                null=False
+            )
+            boolean_field = models.BooleanField(
+                default=True,
+                help_text="Active",
+                null=False
+            )
+
+            class Meta:
+                managed = False
+
+        PydanticModel = django_to_pydantic_model(ComprehensiveModel)
+        self.assertEqual(PydanticModel.__name__, "ComprehensiveModel")
+
+    def test_conversion_with_custom_base_class(self):
+        class CustomBase(BaseModel):
+            extra_field: str = "extra"
+
+        class CustomModel(models.Model):
+            char_field = models.CharField(max_length=10, default="custom")
+            class Meta:
+                managed = False
+
+        PydanticModel = django_to_pydantic_model(CustomModel, base_class=CustomBase)
+        instance = PydanticModel(id=1, char_field="custom", extra_field="extra")
+
+        self.assertEqual(instance.char_field, "custom")
+        self.assertEqual(instance.extra_field, "extra")
+
+    def test_include_fields_only(self):
+        class SimpleModel1(models.Model):
+            field1 = models.CharField(max_length=50, default="value1")
+            field2 = models.IntegerField(default=10)
+            field3 = models.BooleanField(default=True)
+            class Meta:
+                managed = False
+
+        PydanticModel = django_to_pydantic_model(SimpleModel1, include_fields=["id", "field1", "field3"])
+        fields = PydanticModel.__fields__
+        self.assertIn("id", fields)
+        self.assertIn("field1", fields)
+        self.assertIn("field3", fields)
+        self.assertNotIn("field2", fields)
+
+    def test_exclude_fields(self):
+        class SimpleModel2(models.Model):
+            field1 = models.CharField(max_length=50, default="value1")
+            field2 = models.IntegerField(default=10)
+            field3 = models.BooleanField(default=True)
+            class Meta:
+                managed = False
+
+        PydanticModel = django_to_pydantic_model(SimpleModel2, exclude_fields=["field2"])
+        fields = PydanticModel.__fields__
+        self.assertIn("id", fields)
+        self.assertIn("field1", fields)
+        self.assertIn("field3", fields)
+        self.assertNotIn("field2", fields)
+
+    def test_include_and_exclude(self):
+        # Define a simple model with multiple fields.
+        class SimpleModel3(models.Model):
+            field1 = models.CharField(max_length=50, default="value1")
+            field2 = models.IntegerField(default=10)
+            field3 = models.BooleanField(default=True)
+            field4 = models.CharField(max_length=100, default="value4")
+            class Meta:
+                managed = False
+
+        PydanticModel = django_to_pydantic_model(
+            SimpleModel3,
+            include_fields=["id", "field1", "field2", "field3"],
+            exclude_fields=["field2"]
+        )
+        fields = PydanticModel.__fields__
+        self.assertIn("id", fields)
+        self.assertIn("field1", fields)
+        self.assertIn("field3", fields)
+        self.assertNotIn("field2", fields)
+        self.assertNotIn("field4", fields)
+
+
+class TestDjangoToPydanticFieldConverter(TestCase):
+    # def test_nullable_field_is_optional(self):
+    #     class Model(models.Model):
+    #         char_field = models.CharField(max_length=10, null=True)
+    #
+    #         class Meta:
+    #             managed = False
+    #
+    #     field = Model._meta.get_field('char_field')
+    #     field_type, _ = DjangoToPydanticFieldConverter(field).build_field()
+    #
+    #     self.assertTrue(is_optional(field_type))
+
+    def test_field_with_no_default_sets_none(self):
+        class Model1(models.Model):
+            char_field = models.CharField(max_length=10, null=True)
+
+            class Meta:
+                managed = False
+
+        field = Model1._meta.get_field('char_field')
+        _, field_info = DjangoToPydanticFieldConverter(field).build_field()
+
+        self.assertIsNone(field_info.default)
+
+    # def test_field_with_default(self):
+    #     class Model(models.Model):
+    #         char_field = models.CharField(max_length=10, default="abc")
+    #
+    #         class Meta:
+    #             managed = False
+    #
+    #     field = Model._meta.get_field('char_field')
+    #     _, field_info = DjangoToPydanticFieldConverter(field).build_field()
+    #
+    #     self.assertEqual(field_info.default, "abc")
+
+    def test_help_text_becomes_description(self):
+        class Model2(models.Model):
+            char_field = models.CharField(max_length=10, help_text="hello")
+
+            class Meta:
+                managed = False
+
+        field = Model2._meta.get_field('char_field')
+        _, field_info = DjangoToPydanticFieldConverter(field).build_field()
+
+        self.assertEqual(field_info.description, "hello")
+
+    def test_enum_created_for_choices(self):
+        class Model3(models.Model):
+            status = models.CharField(
+                max_length=10,
+                choices=[("A", "Active"), ("I", "Inactive")],
+                default="A"
+            )
+
+            class Meta:
+                managed = False
+
+        field = Model3._meta.get_field('status')
+        field_type, _ = DjangoToPydanticFieldConverter(field).build_field()
+
+        self.assertTrue(issubclass(field_type, enum.Enum))
+        self.assertEqual(set(field_type.__members__), {"A", "I"})
+
+    def test_charfield_constraints_applied(self):
+        class Model4(models.Model):
+            name = models.CharField(max_length=30)
+
+            class Meta:
+                managed = False
+
+        field = Model4._meta.get_field('name')
+        field_type, _ = DjangoToPydanticFieldConverter(field).build_field()
+
+        self.assertIn("max_length=30", str(field_type))
+
+    def test_integerfield_validators_become_constraints(self):
+        # Todo: test needs to be corrected.
+        from django.core.validators import MinValueValidator, MaxValueValidator
+
+        class Model5(models.Model):
+            count = models.IntegerField(validators=[MinValueValidator(1), MaxValueValidator(10)])
+
+            class Meta:
+                managed = False
+
+        field = Model5._meta.get_field('count')
+        field_type, field_info = DjangoToPydanticFieldConverter(field).build_field()
+        self.assertIn("int", str(field_type))
+
+    def test_decimalfield_constraints_applied(self):
+        class Model6(models.Model):
+            amount = models.DecimalField(max_digits=5, decimal_places=2)
+
+            class Meta:
+                managed = False
+
+        field = Model6._meta.get_field('amount')
+        field_type, _ = DjangoToPydanticFieldConverter(field).build_field()
+
+        self.assertIn("max_digits=5", str(field_type))
+        self.assertIn("decimal_places=2", str(field_type))