university-messaging 0.1.0__tar.gz

university_messaging-0.1.0/.gitignore

@@ -0,0 +1,42 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.venv/
+venv/
+.nox/
+.tox/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+coverage.xml
+htmlcov/
+
+# Django
+*.sqlite3
+# Local user uploads (never the university.media source package).
+/media/
+/private-media/
+example_project/media/
+example_project/private-media/
+staticfiles/
+
+# Secrets — never commit
+.env
+.env.*
+!.env.example
+*.pem
+*.key
+
+# Editors / OS
+.idea/
+.vscode/
+.DS_Store
+Thumbs.db
+
+# GistLoop is a separate project with its own repository.
+/GistLoop/

university_messaging-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [YEAR] [COPYRIGHT HOLDER]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

university_messaging-0.1.0/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.5
+Name: university-messaging
+Version: 0.1.0
+Summary: University Messaging: Direct and group messaging with message requests, read receipts and encryption at rest.
+Author-email: Ifeanyi Stanley <nnamaniifeanyi10@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Framework :: Django :: 6.1
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: cryptography>=42
+Requires-Dist: university-core<0.2,>=0.1.1
+Provides-Extra: test
+Requires-Dist: drf-spectacular>=0.27; extra == 'test'
+Requires-Dist: pytest-cov>=5; extra == 'test'
+Requires-Dist: pytest-django>=4.8; extra == 'test'
+Requires-Dist: pytest>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# university-messaging
+
+Direct and group messaging with message requests, read receipts and encryption at rest.
+
+An optional **level-two** module of the University platform.
+
+## Installation
+
+```bash
+pip install university-messaging
+```
+
+```python
+INSTALLED_APPS = [
+    # ...
+    *CORE_APPS,
+    "university.messaging",
+]
+```
+
+Run `python manage.py migrate`. The module's API is mounted automatically under
+`/api/v1/messaging/`.
+
+## Configuration
+
+```python
+UNIVERSITY = {
+    "MESSAGING": {
+        "ENABLED": True,
+    },
+}
+```
+
+## Permissions
+
+| Code | Scope | Description |
+| --- | --- | --- |
+| `messaging.items.create` | platform | Create items |
+
+## Events
+
+| Event | Payload |
+| --- | --- |
+| `messaging.item.created` | `item_id`, `owner_id` |

university_messaging-0.1.0/README.md

@@ -0,0 +1,44 @@
+# university-messaging
+
+Direct and group messaging with message requests, read receipts and encryption at rest.
+
+An optional **level-two** module of the University platform.
+
+## Installation
+
+```bash
+pip install university-messaging
+```
+
+```python
+INSTALLED_APPS = [
+    # ...
+    *CORE_APPS,
+    "university.messaging",
+]
+```
+
+Run `python manage.py migrate`. The module's API is mounted automatically under
+`/api/v1/messaging/`.
+
+## Configuration
+
+```python
+UNIVERSITY = {
+    "MESSAGING": {
+        "ENABLED": True,
+    },
+}
+```
+
+## Permissions
+
+| Code | Scope | Description |
+| --- | --- | --- |
+| `messaging.items.create` | platform | Create items |
+
+## Events
+
+| Event | Payload |
+| --- | --- |
+| `messaging.item.created` | `item_id`, `owner_id` |

university_messaging-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["hatchling>=1.24"]
+build-backend = "hatchling.build"
+
+[project]
+name = "university-messaging"
+dynamic = ["version"]
+description = "University Messaging: Direct and group messaging with message requests, read receipts and encryption at rest."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+authors = [{ name = "Ifeanyi Stanley", email = "nnamaniifeanyi10@gmail.com" }]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Framework :: Django",
+    "Framework :: Django :: 5.2",
+    "Framework :: Django :: 6.0",
+    "Framework :: Django :: 6.1",
+    "Programming Language :: Python :: 3 :: Only",
+    "Typing :: Typed",
+]
+# Level-two modules depend on Core only. Depend on another module only when
+# unavoidable, and never in a cycle.
+dependencies = ["university-core>=0.1.1,<0.2", "cryptography>=42"]
+
+[project.optional-dependencies]
+test = ["pytest>=8", "pytest-django>=4.8", "pytest-cov>=5", "drf-spectacular>=0.27"]
+
+[tool.hatch.version]
+path = "src/university/messaging/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/university"]
+
+[tool.pytest.ini_options]
+DJANGO_SETTINGS_MODULE = "tests.settings"
+pythonpath = ["."]
+testpaths = ["tests"]
+addopts = "-ra --strict-markers"
+markers = ["security: security regression tests"]

university_messaging-0.1.0/src/university/messaging/__init__.py

@@ -0,0 +1,3 @@
+"""University Messaging: direct and group conversations with message requests and encryption at rest."""
+
+__version__ = "0.1.0"

university_messaging-0.1.0/src/university/messaging/admin.py

@@ -0,0 +1,12 @@
+from django.contrib import admin
+
+from university.messaging.models import Conversation
+
+
+@admin.register(Conversation)
+class ConversationAdmin(admin.ModelAdmin):
+    """Metadata only: message text is private and never shown in the admin."""
+
+    list_display = ("id", "kind", "last_message_at", "created_at")
+    list_filter = ("kind",)
+    readonly_fields = ("kind", "title", "created_by", "direct_key", "last_message_at")

university_messaging-0.1.0/src/university/messaging/api/v1/serializers.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from typing import Any
+
+from rest_framework import serializers
+
+from university.core.api.schema import extend_schema_field
+from university.messaging.models import Message, Participant, ParticipantState
+from university.users.refs import PersonRefSerializer, person_ref
+
+PLACEHOLDERS = {"deleted": "This message was deleted.", "hidden": "This message was removed by the moderators."}
+
+
+class MessagingMessageSerializer(serializers.Serializer):
+    id = serializers.UUIDField(read_only=True)
+    conversation = serializers.UUIDField(source="conversation_id", read_only=True)
+    sender = serializers.SerializerMethodField()
+    body = serializers.SerializerMethodField()
+    status = serializers.CharField(read_only=True)
+    reply_to = serializers.UUIDField(source="reply_to_id", read_only=True, allow_null=True)
+    is_mine = serializers.SerializerMethodField()
+    edited_at = serializers.DateTimeField(read_only=True, allow_null=True)
+    created_at = serializers.DateTimeField(read_only=True)
+
+    @extend_schema_field(PersonRefSerializer(allow_null=True))
+    def get_sender(self, obj: Message) -> dict[str, Any] | None:
+        return person_ref(obj.sender)
+
+    def get_body(self, obj: Message) -> str:
+        return obj.text if obj.status == "visible" else PLACEHOLDERS.get(obj.status, "")
+
+    def get_is_mine(self, obj: Message) -> bool:
+        viewer = self.context.get("viewer")
+        return bool(viewer is not None and obj.sender_id == viewer.pk)
+
+
+class MessagingConversationSerializer(serializers.Serializer):
+    """A conversation as one participant sees it."""
+
+    id = serializers.UUIDField(source="conversation_id", read_only=True)
+    kind = serializers.CharField(source="conversation.kind", read_only=True)
+    title = serializers.SerializerMethodField()
+    participants = serializers.SerializerMethodField()
+    state = serializers.CharField(read_only=True)
+    is_admin = serializers.BooleanField(read_only=True)
+    muted = serializers.BooleanField(read_only=True)
+    archived = serializers.BooleanField(read_only=True)
+    unread_count = serializers.SerializerMethodField()
+    last_message = serializers.SerializerMethodField()
+    last_message_at = serializers.DateTimeField(source="conversation.last_message_at", read_only=True, allow_null=True)
+
+    def _others(self, obj: Participant) -> list[Participant]:
+        cache = self.context.setdefault("_others", {})
+        if obj.conversation_id not in cache:
+            cache[obj.conversation_id] = list(
+                obj.conversation.participants.exclude(user_id=obj.user_id)
+                .exclude(state__in=[ParticipantState.LEFT, ParticipantState.DECLINED])
+                .select_related("user")
+            )
+        return cache[obj.conversation_id]
+
+    def get_title(self, obj: Participant) -> str:
+        if obj.conversation.title:
+            return obj.conversation.title
+        names = [p.user.display_name or p.user.handle or "" for p in self._others(obj)]
+        return ", ".join(n for n in names if n)[:100] or "Conversation"
+
+    @extend_schema_field(PersonRefSerializer(many=True))
+    def get_participants(self, obj: Participant) -> list[dict[str, Any] | None]:
+        return [person_ref(p.user) for p in self._others(obj)]
+
+    def get_unread_count(self, obj: Participant) -> int:
+        return int(getattr(obj, "unread", 0) or 0)
+
+    @extend_schema_field(MessagingMessageSerializer(allow_null=True))
+    def get_last_message(self, obj: Participant) -> dict[str, Any] | None:
+        message_id = getattr(obj, "last_message_id", None)
+        if not message_id:
+            return None
+        message = Message.objects.select_related("sender").filter(pk=message_id).first()
+        return MessagingMessageSerializer(message, context=self.context).data if message else None
+
+
+class MessagingStartSerializer(serializers.Serializer):
+    participant_ids = serializers.ListField(child=serializers.UUIDField(), min_length=1, max_length=49)
+    body = serializers.CharField(max_length=20000)
+    title = serializers.CharField(max_length=100, required=False, allow_blank=True)
+
+
+class MessagingSendSerializer(serializers.Serializer):
+    body = serializers.CharField(max_length=20000)
+    reply_to = serializers.UUIDField(required=False, allow_null=True)
+
+
+class MessagingEditSerializer(serializers.Serializer):
+    body = serializers.CharField(max_length=20000)
+
+
+class MessagingConversationUpdateSerializer(serializers.Serializer):
+    title = serializers.CharField(max_length=100, required=False, allow_blank=True)
+    muted = serializers.BooleanField(required=False)
+    archived = serializers.BooleanField(required=False)
+
+
+class MessagingAddParticipantsSerializer(serializers.Serializer):
+    user_ids = serializers.ListField(child=serializers.UUIDField(), min_length=1, max_length=49)
+
+
+class MessagingUnreadSerializer(serializers.Serializer):
+    conversations = serializers.IntegerField()
+    messages = serializers.IntegerField()
+    requests = serializers.IntegerField()
+
+
+class MessagingSettingsSerializer(serializers.Serializer):
+    allow_requests = serializers.BooleanField()

university_messaging-0.1.0/src/university/messaging/api/v1/urls.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from django.urls import path
+
+from university.messaging.api.v1 import views
+
+app_name = "messaging"
+
+urlpatterns = [
+    path("conversations/", views.ConversationListCreateView.as_view(), name="conversation-list"),
+    path("conversations/<uuid:conversation_id>/", views.ConversationDetailView.as_view(), name="conversation-detail"),
+    path("conversations/<uuid:conversation_id>/accept/", views.AcceptView.as_view(), name="conversation-accept"),
+    path("conversations/<uuid:conversation_id>/decline/", views.DeclineView.as_view(), name="conversation-decline"),
+    path("conversations/<uuid:conversation_id>/read/", views.ReadView.as_view(), name="conversation-read"),
+    path("conversations/<uuid:conversation_id>/leave/", views.LeaveView.as_view(), name="conversation-leave"),
+    path("conversations/<uuid:conversation_id>/participants/", views.ParticipantsView.as_view(), name="participants"),
+    path("conversations/<uuid:conversation_id>/messages/", views.MessageListCreateView.as_view(), name="messages"),
+    path("messages/<uuid:message_id>/", views.MessageDetailView.as_view(), name="message-detail"),
+    path("unread/", views.UnreadView.as_view(), name="unread"),
+    path("settings/", views.SettingsView.as_view(), name="settings"),
+]

university_messaging-0.1.0/src/university/messaging/api/v1/views.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+from typing import Any
+
+from rest_framework import permissions, status
+from rest_framework.request import Request
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from university.core.api.pagination import CursorPagination, PageNumberPagination
+from university.core.api.schema import OpenApiParameter, extend_schema, paginated
+from university.messaging import selectors, services
+from university.messaging.api.v1 import serializers as s
+from university.messaging.models import Participant
+
+
+class MessagePagination(CursorPagination):
+    ordering = ("-created_at", "-id")
+
+
+def _conversation(request: Request, participant: Participant) -> dict[str, Any]:
+    annotated = selectors.participations(request.user, "inbox").filter(pk=participant.pk).first() or next(
+        (
+            p
+            for f in ("requests", "archived")
+            for p in selectors.participations(request.user, f).filter(pk=participant.pk)
+        ),
+        participant,
+    )
+    return s.MessagingConversationSerializer(annotated, context={"viewer": request.user}).data
+
+
+class ConversationListCreateView(APIView):
+    permission_classes = [permissions.IsAuthenticated]
+
+    @extend_schema(
+        parameters=[OpenApiParameter("folder", str, description="inbox (default), requests or archived")],
+        responses=paginated(s.MessagingConversationSerializer),
+    )
+    def get(self, request: Request) -> Response:
+        qs = selectors.participations(request.user, request.query_params.get("folder", "inbox"))
+        paginator = PageNumberPagination()
+        page = paginator.paginate_queryset(qs, request, view=self)
+        context = {"viewer": request.user}
+        return paginator.get_paginated_response(
+            s.MessagingConversationSerializer(page, many=True, context=context).data
+        )
+
+    @extend_schema(request=s.MessagingStartSerializer, responses={201: s.MessagingConversationSerializer})
+    def post(self, request: Request) -> Response:
+        serializer = s.MessagingStartSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        conversation, _ = services.start_conversation(sender=request.user, **serializer.validated_data)
+        participant = services.membership(request.user, conversation.pk)
+        return Response(_conversation(request, participant), status=status.HTTP_201_CREATED)
+
+
+class ConversationDetailView(APIView):
+    permission_classes = [permissions.IsAuthenticated]
+
+    @extend_schema(responses=s.MessagingConversationSerializer)
+    def get(self, request: Request, conversation_id: Any) -> Response:
+        return Response(_conversation(request, services.membership(request.user, conversation_id)))
+
+    @extend_schema(request=s.MessagingConversationUpdateSerializer, responses=s.MessagingConversationSerializer)
+    def patch(self, request: Request, conversation_id: Any) -> Response:
+        serializer = s.MessagingConversationUpdateSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        data = serializer.validated_data
+        if "title" in data:
+            services.rename(user=request.user, conversation_id=conversation_id, title=data["title"])
+        participant = services.update_participation(
+            user=request.user, conversation_id=conversation_id, muted=data.get("muted"), archived=data.get("archived")
+        )
+        return Response(_conversation(request, participant))
+
+
+class _RequestResponseView(APIView):
+    permission_classes = [permissions.IsAuthenticated]
+    accept = True
+
+    @extend_schema(request=None, responses=s.MessagingConversationSerializer)
+    def post(self, request: Request, conversation_id: Any) -> Response:
+        participant = services.respond_to_request(
+            user=request.user, conversation_id=conversation_id, accept=self.accept
+        )
+        return Response(s.MessagingConversationSerializer(participant, context={"viewer": request.user}).data)
+
+
+class AcceptView(_RequestResponseView):
+    accept = True
+
+
+class DeclineView(_RequestResponseView):
+    accept = False
+
+
+class ReadView(APIView):
+    permission_classes = [permissions.IsAuthenticated]
+
+    @extend_schema(request=None, responses={204: None})
+    def post(self, request: Request, conversation_id: Any) -> Response:
+        services.mark_read(user=request.user, conversation_id=conversation_id)
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class LeaveView(APIView):
+    permission_classes = [permissions.IsAuthenticated]
+
+    @extend_schema(request=None, responses={204: None})
+    def post(self, request: Request, conversation_id: Any) -> Response:
+        services.leave(user=request.user, conversation_id=conversation_id)
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class ParticipantsView(APIView):
+    permission_classes = [permissions.IsAuthenticated]
+
+    @extend_schema(request=s.MessagingAddParticipantsSerializer, responses=s.MessagingConversationSerializer)
+    def post(self, request: Request, conversation_id: Any) -> Response:
+        serializer = s.MessagingAddParticipantsSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        services.add_participants(user=request.user, conversation_id=conversation_id, **serializer.validated_data)
+        return Response(_conversation(request, services.membership(request.user, conversation_id)))
+
+
+class MessageListCreateView(APIView):
+    permission_classes = [permissions.IsAuthenticated]
+
+    @property
+    def throttle_scope(self) -> str | None:  # type: ignore[override]
+        return "messaging_send" if self.request.method == "POST" else None
+
+    @extend_schema(
+        parameters=[OpenApiParameter("cursor", str)], responses=paginated(s.MessagingMessageSerializer, style="cursor")
+    )
+    def get(self, request: Request, conversation_id: Any) -> Response:
+        services.membership(request.user, conversation_id)
+        paginator = MessagePagination()
+        page = paginator.paginate_queryset(selectors.messages(conversation_id), request, view=self)
+        data = s.MessagingMessageSerializer(page, many=True, context={"viewer": request.user}).data
+        return paginator.get_paginated_response(data)
+
+    @extend_schema(request=s.MessagingSendSerializer, responses={201: s.MessagingMessageSerializer})
+    def post(self, request: Request, conversation_id: Any) -> Response:
+        serializer = s.MessagingSendSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        message = services.send_message(
+            sender=request.user, conversation_id=conversation_id, **serializer.validated_data
+        )
+        data = s.MessagingMessageSerializer(message, context={"viewer": request.user}).data
+        return Response(data, status=status.HTTP_201_CREATED)
+
+
+class MessageDetailView(APIView):
+    permission_classes = [permissions.IsAuthenticated]
+
+    @extend_schema(request=s.MessagingEditSerializer, responses=s.MessagingMessageSerializer)
+    def patch(self, request: Request, message_id: Any) -> Response:
+        serializer = s.MessagingEditSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        message = services.edit_message(
+            user=request.user, message_id=message_id, body=serializer.validated_data["body"]
+        )
+        return Response(s.MessagingMessageSerializer(message, context={"viewer": request.user}).data)
+
+    @extend_schema(responses=s.MessagingMessageSerializer)
+    def delete(self, request: Request, message_id: Any) -> Response:
+        message = services.delete_message(user=request.user, message_id=message_id)
+        return Response(s.MessagingMessageSerializer(message, context={"viewer": request.user}).data)
+
+
+class UnreadView(APIView):
+    permission_classes = [permissions.IsAuthenticated]
+
+    @extend_schema(responses=s.MessagingUnreadSerializer)
+    def get(self, request: Request) -> Response:
+        return Response(selectors.unread_totals(request.user))
+
+
+class SettingsView(APIView):
+    permission_classes = [permissions.IsAuthenticated]
+
+    @extend_schema(responses=s.MessagingSettingsSerializer)
+    def get(self, request: Request) -> Response:
+        return Response({"allow_requests": services.settings_for(request.user).allow_requests})
+
+    @extend_schema(request=s.MessagingSettingsSerializer, responses=s.MessagingSettingsSerializer)
+    def patch(self, request: Request) -> Response:
+        serializer = s.MessagingSettingsSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        updated = services.update_settings(request.user, **serializer.validated_data)
+        return Response({"allow_requests": updated.allow_requests})

university_messaging-0.1.0/src/university/messaging/apps.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import datetime as dt
+from collections.abc import Iterable
+from typing import Any
+
+from django.utils import timezone
+from django.utils.translation import gettext_lazy as _
+
+from university.core.declarations import RetentionPolicy
+from university.core.hooks import Hook, HookRegistry
+from university.core.modules import UniversityAppConfig
+from university.messaging import __version__
+
+
+class MessagingConfig(UniversityAppConfig):
+    name = "university.messaging"
+    label = "university_messaging"
+    verbose_name = _("University Messaging")
+    module_name = "messaging"
+    module_version = __version__
+    module_requires = ("core", "users", "permissions", "audit")
+    settings_namespace = "MESSAGING"
+    api_prefix = "messaging/"
+    api_urlconfs = {"v1": "university.messaging.api.v1.urls"}
+
+    def get_content_adapters(self) -> list[Any]:
+        from university.messaging.content import MessageAdapter
+
+        return [MessageAdapter()]
+
+    def get_throttle_rates(self) -> dict[str, str | None]:
+        return {
+            "messaging_new_conversation": "30/day",
+            "messaging_message": "120/minute",
+            "messaging_send": "120/minute",
+        }
+
+    def get_retention_policies(self) -> Iterable[RetentionPolicy]:
+        from university.core.retention import delete_queryset
+        from university.messaging.conf import messaging_settings
+        from university.messaging.models import Message, MessageStatus
+
+        def cutoff() -> dt.datetime | None:
+            days = messaging_settings.get("DELETED_RETENTION_DAYS")
+            return None if days is None else timezone.now() - dt.timedelta(days=int(days))
+
+        return [
+            RetentionPolicy(
+                name="messaging.deleted_messages",
+                description="Tombstones of messages their senders deleted.",
+                setting="MESSAGING.DELETED_RETENTION_DAYS",
+                cutoff=cutoff,
+                purge=lambda c, dry: delete_queryset(
+                    Message.objects.filter(status=MessageStatus.DELETED, deleted_at__lt=c), dry
+                ),
+            )
+        ]
+
+    def register_hooks(self, hooks: HookRegistry) -> None:
+        from university.messaging import integrations
+
+        hooks.register(Hook.USER_EXPORT_DATA, integrations.export_data)
+        hooks.register(Hook.USER_PURGE, integrations.purge)

university_messaging-0.1.0/src/university/messaging/conf.py

@@ -0,0 +1,22 @@
+"""Settings for the messaging module (``UNIVERSITY["MESSAGING"]``)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from university.core.conf import ModuleSettings
+
+DEFAULTS: dict[str, Any] = {
+    "MESSAGE_MAX_LENGTH": 4000,
+    "MAX_GROUP_SIZE": 50,
+    # Senders can edit a message for this long after sending it.
+    "EDIT_WINDOW_MINUTES": 15,
+    # Fernet keys (urlsafe base64, 32 bytes) encrypting message text at rest. The first key
+    # encrypts; all keys decrypt (rotation). Empty: a key is derived from SECURITY.HMAC_KEY.
+    "ENCRYPTION_KEYS": [],
+    "REQUIRE_VERIFIED_EMAIL": True,
+    # Deleted messages keep a tombstone ("This message was deleted") for this many days, then go.
+    "DELETED_RETENTION_DAYS": 30,
+}
+
+messaging_settings = ModuleSettings("MESSAGING", DEFAULTS)