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

django_spire/notification/utils.py

@@ -1,7 +1,9 @@
+from __future__ import annotations
+
 from django.conf import settings
 
 from django_spire.consts import NOTIFICATION_THROTTLE_RATE_PER_MINUTE_SETTINGS_NAME
 
 
 def get_throttle_sleep_time() -> float:
-    return float(getattr(settings, NOTIFICATION_THROTTLE_RATE_PER_MINUTE_SETTINGS_NAME) / 60)
+    return float(getattr(settings, NOTIFICATION_THROTTLE_RATE_PER_MINUTE_SETTINGS_NAME) / 60)

django_spire/settings.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+
 DJANGO_SPIRE_AUTH_CONTROLLERS = {
     'ai_chat': 'django_spire.ai.chat.auth.controller.BaseAiChatAuthController',
     'help_desk': 'django_spire.help_desk.auth.controller.BaseHelpDeskAuthController',

django_spire/theme/tests/test_context_processor.py

@@ -20,12 +20,12 @@ class ThemeContextProcessorTests(TestCase):
         with patch('django_spire.conf.settings.DJANGO_SPIRE_DEFAULT_THEME', 'gruvbox-dark'):
             context = theme_context(request)
 
-        self.assertEqual(context['DJANGO_SPIRE_DEFAULT_THEME'], 'gruvbox-dark')
-        self.assertIn('theme', context)
+        assert context['DJANGO_SPIRE_DEFAULT_THEME'] == 'gruvbox-dark'
+        assert 'theme' in context
 
         data = context['theme']
-        self.assertEqual(data['family'], 'gruvbox')
-        self.assertEqual(data['mode'], 'dark')
+        assert data['family'] == 'gruvbox'
+        assert data['mode'] == 'dark'
 
     def test_theme_context_with_cookie(self) -> None:
         request = self.factory.get('/')
@@ -34,10 +34,10 @@ class ThemeContextProcessorTests(TestCase):
 
         context = theme_context(request)
 
-        self.assertIn('theme', context)
+        assert 'theme' in context
         data = context['theme']
-        self.assertEqual(data['family'], 'one-dark')
-        self.assertEqual(data['mode'], 'light')
+        assert data['family'] == 'one-dark'
+        assert data['mode'] == 'light'
 
     def test_theme_context_invalid_cookie(self) -> None:
         request = self.factory.get('/')
@@ -48,30 +48,32 @@ class ThemeContextProcessorTests(TestCase):
             context = theme_context(request)
 
         data = context['theme']
-        self.assertEqual(data['family'], 'gruvbox')
-        self.assertEqual(data['mode'], 'dark')
+        assert data['family'] == 'gruvbox'
+        assert data['mode'] == 'dark'
 
     def test_theme_context_path_setting(self) -> None:
         request = self.factory.get('/')
         request.COOKIES = {}
 
         path = '/custom/path/{family}/{mode}.css'
+
         with patch('django_spire.conf.settings.DJANGO_SPIRE_THEME_PATH', path):
             context = theme_context(request)
 
-        self.assertEqual(context['DJANGO_SPIRE_THEME_PATH'], path)
+        assert context['DJANGO_SPIRE_THEME_PATH'] == path
 
 
 class ThemeContextProcessorIntegrationTests(BaseTestCase):
     def setUp(self) -> None:
         super().setUp()
+
         self.factory = RequestFactory()
 
     def test_theme_context_with_authenticated_client(self) -> None:
         cookie_name = get_theme_cookie_name()
         self.client.cookies[cookie_name] = 'gruvbox-dark'
         response = self.client.get('/')
-        self.assertEqual(response.status_code, 200)
+        assert response.status_code == 200
 
     def test_theme_context_with_media_root_override(self) -> None:
         request = self.factory.get('/')
@@ -80,5 +82,5 @@ class ThemeContextProcessorIntegrationTests(BaseTestCase):
 
         context = theme_context(request)
         data = context['theme']
-        self.assertEqual(data['family'], 'material')
-        self.assertEqual(data['mode'], 'light')
+        assert data['family'] == 'material'
+        assert data['mode'] == 'light'

django_spire/theme/tests/test_enums.py

@@ -21,9 +21,9 @@ class ThemeEnumTests(TestCase):
         }
 
         actual = {family.value for family in ThemeFamily}
-        self.assertEqual(actual, expected)
+        assert actual == expected
 
     def test_theme_modes(self) -> None:
         expected = {'dark', 'light'}
         actual = {mode.value for mode in ThemeMode}
-        self.assertEqual(actual, expected)
+        assert actual == expected

django_spire/theme/tests/test_filesystem.py

@@ -21,7 +21,7 @@ class ThemeFilesystemValidationTests(TestCase):
         if not self.base_path.exists():
             self.skipTest(f'Themes directory does not exist: {self.base_path}. Create it to enable filesystem validation tests.')
 
-        self.assertTrue(self.base_path.is_dir(), f'Themes path is not a directory: {self.base_path}')
+        assert self.base_path.is_dir(), f'Themes path is not a directory: {self.base_path}'
 
     def test_all_theme_families_have_directories(self) -> None:
         if not self.base_path.exists():
@@ -175,7 +175,4 @@ class ThemeFilesystemValidationTests(TestCase):
                     file = directory / filename
 
                     if file.exists():
-                        self.assertEqual(
-                            file.name, filename,
-                            f'Filename {file.name} does not match expected {filename}'
-                        )
+                        assert file.name == filename, f'Filename {file.name} does not match expected {filename}'

django_spire/theme/tests/test_integration.py

@@ -10,39 +10,39 @@ class ThemeIntegrationTests(BaseTestCase):
         for theme in Theme.get_available():
             stylesheet = theme.stylesheet
 
-            self.assertIn(f'{theme.family.value}/', stylesheet)
-            self.assertIn(f'app-{theme.mode.value}.css', stylesheet)
+            assert f'{theme.family.value}/' in stylesheet
+            assert f'app-{theme.mode.value}.css' in stylesheet
 
     def test_roundtrip_conversion(self) -> None:
         for theme in Theme.get_available():
             string = theme.value
             recovered = Theme.from_string(string)
-            self.assertEqual(theme, recovered)
+            assert theme == recovered
 
             dictionary = theme.to_dict()
             recovered2 = Theme.from_string(dictionary['full'])
-            self.assertEqual(theme, recovered2)
+            assert theme == recovered2
 
     def test_display_names_complete(self) -> None:
         for family in ThemeFamily:
-            self.assertIn(family, Theme.FAMILY_DISPLAY_NAMES)
+            assert family in Theme.FAMILY_DISPLAY_NAMES
             display_name = Theme.FAMILY_DISPLAY_NAMES[family]
-            self.assertIsInstance(display_name, str)
-            self.assertTrue(len(display_name) > 0)
+            assert isinstance(display_name, str)
+            assert len(display_name) > 0
 
     def test_theme_integration_with_authenticated_user(self) -> None:
         available = Theme.get_available()
-        self.assertGreater(len(available), 0)
+        assert len(available) > 0
 
         for theme in available[:3]:
             self.client.cookies['app-theme'] = theme.value
             response = self.client.get('/')
-            self.assertEqual(response.status_code, 200)
+            assert response.status_code == 200
 
     def test_theme_media_integration(self) -> None:
         theme = Theme(family=ThemeFamily.GRUVBOX, mode='dark')
         stylesheet = theme.stylesheet
 
-        self.assertIn('django_spire/css/themes/', stylesheet)
-        self.assertIn('gruvbox', stylesheet)
-        self.assertIn('app-dark.css', stylesheet)
+        assert 'django_spire/css/themes/' in stylesheet
+        assert 'gruvbox' in stylesheet
+        assert 'app-dark.css' in stylesheet

django_spire/theme/tests/test_model.py

@@ -14,37 +14,39 @@ class ThemeModelTests(TestCase):
     def test_dataclass_fields(self) -> None:
         theme_fields = {f.name: f.type for f in fields(Theme)}
 
-        self.assertEqual(set(theme_fields.keys()), {'family', 'mode'})
-        self.assertEqual(theme_fields['family'], 'ThemeFamily')
-        self.assertEqual(theme_fields['mode'], 'ThemeMode')
+        assert set(theme_fields.keys()) == {'family', 'mode'}
+        assert theme_fields['family'] == 'ThemeFamily'
+        assert theme_fields['mode'] == 'ThemeMode'
 
     def test_class_variables(self) -> None:
-        self.assertEqual(Theme.DEFAULT_FAMILY, ThemeFamily.DEFAULT)
-        self.assertEqual(Theme.DEFAULT_MODE, ThemeMode.LIGHT)
-        self.assertEqual(Theme.SEPARATOR, '-')
+        assert Theme.DEFAULT_FAMILY == ThemeFamily.DEFAULT
+        assert Theme.DEFAULT_MODE == ThemeMode.LIGHT
+        assert Theme.SEPARATOR == '-'
 
         for family in ThemeFamily:
-            self.assertIn(family, Theme.FAMILY_DISPLAY_NAMES)
+            assert family in Theme.FAMILY_DISPLAY_NAMES
 
     def test_theme_initialization_with_enums(self) -> None:
         theme = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.DARK)
-        self.assertEqual(theme.family, ThemeFamily.GRUVBOX)
-        self.assertEqual(theme.mode, ThemeMode.DARK)
+        assert theme.family == ThemeFamily.GRUVBOX
+        assert theme.mode == ThemeMode.DARK
 
     def test_theme_initialization_with_strings(self) -> None:
         theme = Theme(family='gruvbox', mode='dark')
-        self.assertEqual(theme.family, ThemeFamily.GRUVBOX)
-        self.assertEqual(theme.mode, ThemeMode.DARK)
+        assert theme.family == ThemeFamily.GRUVBOX
+        assert theme.mode == ThemeMode.DARK
 
     def test_theme_initialization_invalid_family(self) -> None:
         with pytest.raises(ValueError) as ctx:
             Theme(family='invalid-family', mode='dark')
-        self.assertIn('Invalid theme family', str(ctx.value))
+
+        assert 'Invalid theme family' in str(ctx.value)
 
     def test_theme_initialization_invalid_mode(self) -> None:
         with pytest.raises(ValueError) as ctx:
             Theme(family='gruvbox', mode='invalid-mode')
-        self.assertIn('Invalid theme mode', str(ctx.value))
+
+        assert 'Invalid theme mode' in str(ctx.value)
 
     def test_from_string_valid(self) -> None:
         cases = [
@@ -57,23 +59,23 @@ class ThemeModelTests(TestCase):
         for string, family, mode in cases:
             with self.subTest(string=string):
                 theme = Theme.from_string(string)
-                self.assertEqual(theme.family, family)
-                self.assertEqual(theme.mode, mode)
+                assert theme.family == family
+                assert theme.mode == mode
 
     def test_from_string_empty_with_default(self) -> None:
         default = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.DARK)
         theme = Theme.from_string('', default=default)
-        self.assertEqual(theme, default)
+        assert theme == default
 
     def test_from_string_empty_without_default(self) -> None:
         theme = Theme.from_string('')
-        self.assertEqual(theme.family, Theme.DEFAULT_FAMILY)
-        self.assertEqual(theme.mode, Theme.DEFAULT_MODE)
+        assert theme.family == Theme.DEFAULT_FAMILY
+        assert theme.mode == Theme.DEFAULT_MODE
 
     def test_from_string_invalid_with_default(self) -> None:
         default = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.DARK)
         theme = Theme.from_string('invalid', default=default)
-        self.assertEqual(theme, default)
+        assert theme == default
 
     def test_from_string_invalid_without_default(self) -> None:
         with pytest.raises(ValueError):
@@ -83,35 +85,35 @@ class ThemeModelTests(TestCase):
         available = Theme.get_available()
 
         count = len(ThemeFamily) * len(ThemeMode)
-        self.assertEqual(len(available), count)
+        assert len(available) == count
 
         for family in ThemeFamily:
             for mode in ThemeMode:
                 theme = Theme(family=family, mode=mode)
-                self.assertIn(theme, available)
+                assert theme in available
 
     def test_get_default(self) -> None:
         default = Theme.get_default()
-        self.assertEqual(default.family, Theme.DEFAULT_FAMILY)
-        self.assertEqual(default.mode, Theme.DEFAULT_MODE)
+        assert default.family == Theme.DEFAULT_FAMILY
+        assert default.mode == Theme.DEFAULT_MODE
 
     def test_display_property(self) -> None:
         theme = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.DARK)
-        self.assertEqual(theme.display, 'Gruvbox - Dark')
+        assert theme.display == 'Gruvbox - Dark'
 
         theme = Theme(family=ThemeFamily.ONE_DARK, mode=ThemeMode.LIGHT)
-        self.assertEqual(theme.display, 'One Dark Pro - Light')
+        assert theme.display == 'One Dark Pro - Light'
 
     def test_family_display_property(self) -> None:
         theme = Theme(family=ThemeFamily.ONE_DARK, mode=ThemeMode.DARK)
-        self.assertEqual(theme.family_display, 'One Dark Pro')
+        assert theme.family_display == 'One Dark Pro'
 
     def test_is_dark_property(self) -> None:
         dark = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.DARK)
-        self.assertTrue(dark.is_dark)
+        assert dark.is_dark
 
         light = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.LIGHT)
-        self.assertFalse(light.is_dark)
+        assert not light.is_dark
 
     def test_stylesheet_property(self) -> None:
         cases = [
@@ -124,7 +126,7 @@ class ThemeModelTests(TestCase):
         for family, mode, path in cases:
             with self.subTest(family=family, mode=mode):
                 theme = Theme(family=family, mode=mode)
-                self.assertEqual(theme.stylesheet, path)
+                assert theme.stylesheet == path
 
     def test_value_property(self) -> None:
         cases = [
@@ -137,7 +139,7 @@ class ThemeModelTests(TestCase):
         for family, mode, value in cases:
             with self.subTest(family=family, mode=mode):
                 theme = Theme(family=family, mode=mode)
-                self.assertEqual(theme.value, value)
+                assert theme.value == value
 
     def test_to_dict(self) -> None:
         theme = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.DARK)
@@ -153,15 +155,15 @@ class ThemeModelTests(TestCase):
             'stylesheet'
         }
 
-        self.assertEqual(set(result.keys()), keys)
+        assert set(result.keys()) == keys
 
-        self.assertEqual(result['display'], 'Gruvbox - Dark')
-        self.assertEqual(result['family'], 'gruvbox')
-        self.assertEqual(result['family_display'], 'Gruvbox')
-        self.assertEqual(result['full'], 'gruvbox-dark')
-        self.assertTrue(result['is_dark'])
-        self.assertEqual(result['mode'], 'dark')
-        self.assertEqual(result['stylesheet'], 'django_spire/css/themes/gruvbox/app-dark.css')
+        assert result['display'] == 'Gruvbox - Dark'
+        assert result['family'] == 'gruvbox'
+        assert result['family_display'] == 'Gruvbox'
+        assert result['full'] == 'gruvbox-dark'
+        assert result['is_dark']
+        assert result['mode'] == 'dark'
+        assert result['stylesheet'] == 'django_spire/css/themes/gruvbox/app-dark.css'
 
     def test_theme_immutability(self) -> None:
         theme = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.DARK)

django_spire/theme/tests/test_views/test_json_views.py

@@ -22,30 +22,30 @@ class ThemeViewTests(TestCase):
         request = self.factory.get('/django_spire/theme/json/get_config/')
         response = json_views.get_config(request)
 
-        self.assertIsInstance(response, JsonResponse)
-        self.assertEqual(response.status_code, HTTPStatus.OK)
+        assert isinstance(response, JsonResponse)
+        assert response.status_code == HTTPStatus.OK
 
         data = json.loads(response.content)
-        self.assertTrue(data['success'])
+        assert data['success']
 
         config = data['data']
-        self.assertIn('families', config)
-        self.assertIn('default_family', config)
-        self.assertIn('default_mode', config)
-        self.assertIn('separator', config)
+        assert 'families' in config
+        assert 'default_family' in config
+        assert 'default_mode' in config
+        assert 'separator' in config
 
         for family in ThemeFamily:
-            self.assertIn(family.value, config['families'])
+            assert family.value in config['families']
             family_config = config['families'][family.value]
-            self.assertIn('name', family_config)
-            self.assertIn('modes', family_config)
-            self.assertEqual(set(family_config['modes']), {'dark', 'light'})
+            assert 'name' in family_config
+            assert 'modes' in family_config
+            assert set(family_config['modes']) == {'dark', 'light'}
 
     def test_get_config_cache_header(self) -> None:
         _ = self.factory.get('/django_spire/theme/json/get_config/')
 
         with patch('django_spire.theme.views.json_views.cache_page') as _:
-            self.assertTrue(hasattr(json_views.get_config, '__wrapped__'))
+            assert hasattr(json_views.get_config, '__wrapped__')
 
     def test_set_theme_success(self) -> None:
         request = self.factory.post(
@@ -55,20 +55,20 @@ class ThemeViewTests(TestCase):
         )
         response = json_views.set_theme(request)
 
-        self.assertIsInstance(response, JsonResponse)
-        self.assertEqual(response.status_code, HTTPStatus.OK)
+        assert isinstance(response, JsonResponse)
+        assert response.status_code == HTTPStatus.OK
 
         data = json.loads(response.content)
-        self.assertTrue(data['success'])
-        self.assertIn('theme', data)
+        assert data['success']
+        assert 'theme' in data
 
         data = data['theme']
-        self.assertEqual(data['family'], 'gruvbox')
-        self.assertEqual(data['mode'], 'dark')
+        assert data['family'] == 'gruvbox'
+        assert data['mode'] == 'dark'
 
         cookie_name = get_theme_cookie_name()
-        self.assertIn(cookie_name, response.cookies)
-        self.assertEqual(response.cookies[cookie_name].value, 'gruvbox-dark')
+        assert cookie_name in response.cookies
+        assert response.cookies[cookie_name].value == 'gruvbox-dark'
 
     def test_set_theme_missing_theme(self) -> None:
         request = self.factory.post(
@@ -78,11 +78,11 @@ class ThemeViewTests(TestCase):
         )
         response = json_views.set_theme(request)
 
-        self.assertEqual(response.status_code, HTTPStatus.BAD_REQUEST)
+        assert response.status_code == HTTPStatus.BAD_REQUEST
         data = json.loads(response.content)
-        self.assertFalse(data['success'])
-        self.assertIn('error', data)
-        self.assertEqual(data['error'], 'Theme is required')
+        assert not data['success']
+        assert 'error' in data
+        assert data['error'] == 'Theme is required'
 
     def test_set_theme_invalid_theme(self) -> None:
         request = self.factory.post(
@@ -92,11 +92,11 @@ class ThemeViewTests(TestCase):
         )
         response = json_views.set_theme(request)
 
-        self.assertEqual(response.status_code, HTTPStatus.BAD_REQUEST)
+        assert response.status_code == HTTPStatus.BAD_REQUEST
         data = json.loads(response.content)
-        self.assertFalse(data['success'])
-        self.assertIn('error', data)
-        self.assertIn('Invalid theme', data['error'])
+        assert not data['success']
+        assert 'error' in data
+        assert 'Invalid theme' in data['error']
 
 
 class ThemeViewIntegrationTests(BaseTestCase):
@@ -107,14 +107,14 @@ class ThemeViewIntegrationTests(BaseTestCase):
             content_type='application/json'
         )
 
-        self.assertEqual(response.status_code, HTTPStatus.OK)
+        assert response.status_code == HTTPStatus.OK
         data = json.loads(response.content)
-        self.assertTrue(data['success'])
+        assert data['success']
 
     def test_get_config_with_authenticated_client(self) -> None:
         response = self.client.get('/django_spire/theme/json/get_config/')
-        self.assertEqual(response.status_code, HTTPStatus.OK)
+        assert response.status_code == HTTPStatus.OK
 
         data = json.loads(response.content)
-        self.assertTrue(data['success'])
-        self.assertIn('families', data['data'])
+        assert data['success']
+        assert 'families' in data['data']

django_spire/theme/urls/json_urls.py

@@ -1,7 +1,10 @@
+from __future__ import annotations
+
 from django.urls import path
 
 from django_spire.theme.views import json_views
 
+
 app_name = 'json'
 
 urlpatterns = [

django_spire/theme/urls/page_urls.py

@@ -1,7 +1,10 @@
+from __future__ import annotations
+
 from django.urls import path
 
 from django_spire.theme.views import page_views
 
+
 app_name = 'page'
 
 urlpatterns = [

django_spire/urls.py

@@ -1,21 +1,25 @@
+from __future__ import annotations
+
 from django.apps import apps
-from django.urls import path, include
+from django.urls import include, path
 
-app_name = 'django_spire'
+from django_spire.exceptions import DjangoSpireConfigurationError
 
-urlpatterns = []
 
-for app_config in apps.get_app_configs():
-    if hasattr(app_config, 'URLPATTERNS_INCLUDE') and hasattr(app_config, 'URLPATTERNS_NAMESPACE'):
-        urlpatterns.append(
-            path(
-                f'{app_config.URLPATTERNS_NAMESPACE}/',
-                include(
-                    app_config.URLPATTERNS_INCLUDE,
-                    namespace=app_config.URLPATTERNS_NAMESPACE,
-                )
-            ),
+app_name = 'django_spire'
+
+urlpatterns = [
+    path(
+        f'{app_config.URLPATTERNS_NAMESPACE}/',
+        include(
+            app_config.URLPATTERNS_INCLUDE,
+            namespace=app_config.URLPATTERNS_NAMESPACE,
         )
+    )
+    for app_config in apps.get_app_configs()
+    if hasattr(app_config, 'URLPATTERNS_INCLUDE') and hasattr(app_config, 'URLPATTERNS_NAMESPACE')
+]
 
-if len(urlpatterns) == 0:
-    raise Exception('You need to have at least one app installed to use Django Spire.')
+if not urlpatterns:
+    message = 'You need to have at least one app installed to use Django Spire.'
+    raise DjangoSpireConfigurationError(message)

django_spire/utils.py

@@ -1,5 +1,12 @@
+from __future__ import annotations
+
 from django.apps import apps
 
+from django_spire.exceptions import (
+    DjangoSpireInvalidClassStringError,
+    DjangoSpireMissingRequiredAppError
+)
+
 
 def app_is_installed(app_label: str) -> bool:
     return app_label in list(apps.app_configs.keys())
@@ -7,17 +14,19 @@ def app_is_installed(app_label: str) -> bool:
 
 def check_required_apps(app_label: str) -> None:
     app_config = apps.get_app_config(app_label)
+
     for required_app_name in app_config.REQUIRED_APPS:
         if not app_is_installed(required_app_name):
-            raise Exception(
-                f"{app_label} requires {required_app_name} is be in the 'INSTALLED_APPS' list before {app_label} in the django settings module.")
+            message = f'{app_label} requires {required_app_name} is be in the "INSTALLED_APPS" list before {app_label} in the django settings module.'
+            raise DjangoSpireMissingRequiredAppError(message)
 
 
 def get_class_from_string(class_string: str) -> type:
     class_parts = class_string.split('.')
 
     if len(class_parts) < 2:
-        raise Exception(f"Class string {class_string} is not a valid class string.")
+        message = f'Class string {class_string} is not a valid class string.'
+        raise DjangoSpireInvalidClassStringError(message)
 
     module_path = '.'.join(class_parts[:-1])
     class_name = class_parts[-1]
@@ -28,4 +37,4 @@ def get_class_from_string(class_string: str) -> type:
 
 
 def get_class_name_from_class(cls: type) -> str:
-    return cls.__module__ + '.' + cls.__qualname__
+    return cls.__module__ + '.' + cls.__qualname__

{django_spire-0.23.7.dist-info → django_spire-0.23.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-spire
-Version: 0.23.7
+Version: 0.23.8
 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.