django-workspaces 0.0.1a1__tar.gz

django_workspaces-0.0.1a1/.editorconfig

@@ -0,0 +1,11 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.py]
+indent_size = 4
+indent_style = space
+max_line_length = 120

django_workspaces-0.0.1a1/.github/dependabot.yml

@@ -0,0 +1,11 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for more information:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: weekly

django_workspaces-0.0.1a1/.github/workflows/release.yml

@@ -0,0 +1,33 @@
+name: Build & Release
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    environment:
+      name: release
+      url: https://pypi.org/p/django-workspaces
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish package
+        uses: pypa/gh-action-pypi-publish@v1.12.4

django_workspaces-0.0.1a1/.github/workflows/test.yml

@@ -0,0 +1,45 @@
+name: test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+concurrency:
+  group: test-${{ github.head_ref }}
+  cancel-in-progress: true
+
+env:
+  PYTHONUNBUFFERED: "1"
+  FORCE_COLOR: "1"
+
+jobs:
+  run:
+    name: Python ${{ matrix.python-version }} on ${{ startsWith(matrix.os, 'macos-') && 'macOS' || startsWith(matrix.os, 'windows-') && 'Windows' || 'Linux' }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install Hatch
+        run: pip install --upgrade hatch
+
+      - name: Run static analysis
+        run: hatch fmt --check
+
+      - name: Run type checks
+        run: hatch run types
+
+      - name: Run tests
+        run: hatch test --python ${{ matrix.python-version }} --cover --randomize --parallel --retries 2 --retry-delay 1

django_workspaces-0.0.1a1/.gitignore

@@ -0,0 +1,2 @@
+__pycache__
+*.sqlite*

django_workspaces-0.0.1a1/.vscode/extensions.json

@@ -0,0 +1,11 @@
+{
+    "recommendations": [
+        "charliermarsh.ruff",
+        "editorconfig.editorconfig",
+        "github.vscode-github-actions",
+        "ms-python.mypy-type-checker",
+        "ms-python.python",
+        "redhat.vscode-yaml",
+        "tombi-toml.tombi"
+    ]
+}

django_workspaces-0.0.1a1/.vscode/settings.json

@@ -0,0 +1,16 @@
+{
+    "[python]": {
+        "editor.formatOnSave": true,
+        "editor.codeActionsOnSave": {
+            "source.organizeImports": "explicit"
+        },
+        "editor.defaultFormatter": "charliermarsh.ruff"
+    },
+    "[toml]": {
+        "editor.defaultFormatter": "tombi-toml.tombi"
+    },
+    "[github-actions-workflow]": {
+        "editor.defaultFormatter": "redhat.vscode-yaml"
+    },
+    "workbench.editor.enablePreview": false
+}

django_workspaces-0.0.1a1/LICENSE.txt

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2025-present Christian Hartung <hartung@live.com>
+
+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.

django_workspaces-0.0.1a1/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: django-workspaces
+Version: 0.0.1a1
+Summary: Django reusable app to manage user workspaces
+Project-URL: Documentation, https://github.com/hartungstenio/django-workspaces#readme
+Project-URL: Issues, https://github.com/hartungstenio/django-workspaces/issues
+Project-URL: Source, https://github.com/hartungstenio/django-workspaces
+Author-email: Christian Hartung <hartung@live.com>
+License-Expression: MIT
+License-File: LICENSE.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: django
+Requires-Dist: django-stubs-ext
+Requires-Dist: typing-extensions; python_version < '3.13'
+Description-Content-Type: text/markdown
+
+# django-workspaces
+
+[![PyPI - Version](https://img.shields.io/pypi/v/django-workspaces.svg)](https://pypi.org/project/django-workspaces)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/django-workspaces.svg)](https://pypi.org/project/django-workspaces)
+
+-----
+
+## Table of Contents
+
+- [Installation](#installation)
+- [License](#license)
+
+## Installation
+
+```console
+pip install django-workspaces
+```
+
+## License
+
+`django-workspaces` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

django_workspaces-0.0.1a1/README.md

@@ -0,0 +1,21 @@
+# django-workspaces
+
+[![PyPI - Version](https://img.shields.io/pypi/v/django-workspaces.svg)](https://pypi.org/project/django-workspaces)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/django-workspaces.svg)](https://pypi.org/project/django-workspaces)
+
+-----
+
+## Table of Contents
+
+- [Installation](#installation)
+- [License](#license)
+
+## Installation
+
+```console
+pip install django-workspaces
+```
+
+## License
+
+`django-workspaces` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

django_workspaces-0.0.1a1/demo/asgi.py

@@ -0,0 +1,16 @@
+"""
+ASGI config for demo project.
+
+It exposes the ASGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/5.2/howto/deployment/asgi/
+"""
+
+import os
+
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "demo.settings")
+
+application = get_asgi_application()

django_workspaces-0.0.1a1/demo/settings.py

@@ -0,0 +1,124 @@
+"""
+Django settings for demo project.
+
+Generated by 'django-admin startproject' using Django 5.2.3.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/5.2/topics/settings/
+
+For the full list of settings and their values, see
+https://docs.djangoproject.com/en/5.2/ref/settings/
+"""
+
+from pathlib import Path
+
+# Build paths inside the project like this: BASE_DIR / 'subdir'.
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+
+# Quick-start development settings - unsuitable for production
+# See https://docs.djangoproject.com/en/5.2/howto/deployment/checklist/
+
+# SECURITY WARNING: keep the secret key used in production secret!
+SECRET_KEY = "django-insecure-x(5$zg(%mx=mseor=#=$-#!mn-+wpwhv8a7-kn%se4dv_fc-4r"  # noqa: S105
+
+# SECURITY WARNING: don't run with debug turned on in production!
+DEBUG = True
+
+ALLOWED_HOSTS = ["localhost"]
+
+
+# Application definition
+
+INSTALLED_APPS = [
+    "django.contrib.admin",
+    "django.contrib.auth",
+    "django.contrib.contenttypes",
+    "django.contrib.sessions",
+    "django.contrib.messages",
+    "django.contrib.staticfiles",
+    "django_workspaces",
+]
+
+MIDDLEWARE = [
+    "django.middleware.security.SecurityMiddleware",
+    "django.contrib.sessions.middleware.SessionMiddleware",
+    "django.middleware.common.CommonMiddleware",
+    "django.middleware.csrf.CsrfViewMiddleware",
+    "django.contrib.auth.middleware.AuthenticationMiddleware",
+    "django_workspaces.middleware.workspace_middleware",
+    "django.contrib.messages.middleware.MessageMiddleware",
+    "django.middleware.clickjacking.XFrameOptionsMiddleware",
+]
+
+ROOT_URLCONF = "demo.urls"
+
+TEMPLATES = [
+    {
+        "BACKEND": "django.template.backends.django.DjangoTemplates",
+        "DIRS": [],
+        "APP_DIRS": True,
+        "OPTIONS": {
+            "context_processors": [
+                "django.template.context_processors.request",
+                "django.contrib.auth.context_processors.auth",
+                "django.contrib.messages.context_processors.messages",
+            ],
+        },
+    },
+]
+
+WSGI_APPLICATION = "demo.wsgi.application"
+
+
+# Database
+# https://docs.djangoproject.com/en/5.2/ref/settings/#databases
+
+DATABASES = {
+    "default": {
+        "ENGINE": "django.db.backends.sqlite3",
+        "NAME": BASE_DIR / "db.sqlite3",
+    }
+}
+
+
+# Password validation
+# https://docs.djangoproject.com/en/5.2/ref/settings/#auth-password-validators
+
+AUTH_PASSWORD_VALIDATORS = [
+    {
+        "NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator",
+    },
+    {
+        "NAME": "django.contrib.auth.password_validation.MinimumLengthValidator",
+    },
+    {
+        "NAME": "django.contrib.auth.password_validation.CommonPasswordValidator",
+    },
+    {
+        "NAME": "django.contrib.auth.password_validation.NumericPasswordValidator",
+    },
+]
+
+
+# Internationalization
+# https://docs.djangoproject.com/en/5.2/topics/i18n/
+
+LANGUAGE_CODE = "en-us"
+
+TIME_ZONE = "UTC"
+
+USE_I18N = True
+
+USE_TZ = True
+
+
+# Static files (CSS, JavaScript, Images)
+# https://docs.djangoproject.com/en/5.2/howto/static-files/
+
+STATIC_URL = "static/"
+
+# Default primary key field type
+# https://docs.djangoproject.com/en/5.2/ref/settings/#default-auto-field
+
+DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField"

django_workspaces-0.0.1a1/demo/urls.py

@@ -0,0 +1,23 @@
+"""
+URL configuration for demo project.
+
+The `urlpatterns` list routes URLs to views. For more information please see:
+    https://docs.djangoproject.com/en/5.2/topics/http/urls/
+Examples:
+Function views
+    1. Add an import:  from my_app import views
+    2. Add a URL to urlpatterns:  path('', views.home, name='home')
+Class-based views
+    1. Add an import:  from other_app.views import Home
+    2. Add a URL to urlpatterns:  path('', Home.as_view(), name='home')
+Including another URLconf
+    1. Import the include() function: from django.urls import include, path
+    2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))
+"""
+
+from django.contrib import admin
+from django.urls import path
+
+urlpatterns = [
+    path("admin/", admin.site.urls),
+]

django_workspaces-0.0.1a1/demo/wsgi.py

@@ -0,0 +1,16 @@
+"""
+WSGI config for demo project.
+
+It exposes the WSGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/5.2/howto/deployment/wsgi/
+"""
+
+import os
+
+from django.core.wsgi import get_wsgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "demo.settings")
+
+application = get_wsgi_application()

django_workspaces-0.0.1a1/manage.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python
+"""Django's command-line utility for administrative tasks."""
+
+import os
+import sys
+
+
+def main() -> None:
+    """Run administrative tasks."""
+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "demo.settings")
+    try:
+        from django.core.management import execute_from_command_line  # noqa: PLC0415
+    except ImportError as exc:
+        msg = (
+            "Couldn't import Django. Are you sure it's installed and "
+            "available on your PYTHONPATH environment variable? Did you "
+            "forget to activate a virtual environment?"
+        )
+        raise ImportError(msg) from exc
+    execute_from_command_line(sys.argv)
+
+
+if __name__ == "__main__":
+    main()

django_workspaces-0.0.1a1/pyproject.toml

@@ -0,0 +1,192 @@
+[project]
+name = "django-workspaces"
+description = "Django reusable app to manage user workspaces"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [
+  { name = "Christian Hartung", email = "hartung@live.com" },
+]
+keywords = []
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Web Environment",
+  "Framework :: Django",
+  "Framework :: Django :: 5.2",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Programming Language :: Python :: Implementation :: PyPy",
+  "Topic :: Internet :: WWW/HTTP",
+  "Typing :: Typed",
+]
+dependencies = [
+  "django",
+  "django-stubs-ext",
+  "typing-extensions; python_version<'3.13'",
+]
+dynamic = ["version"]
+
+[project.urls]
+Documentation = "https://github.com/hartungstenio/django-workspaces#readme"
+Issues = "https://github.com/hartungstenio/django-workspaces/issues"
+Source = "https://github.com/hartungstenio/django-workspaces"
+
+[build-system]
+requires = ["hatch-vcs", "hatchling"]
+build-backend = "hatchling.build"
+
+[tool.coverage.run]
+source_pkgs = ["django_workspaces", "tests"]
+branch = true
+parallel = true
+omit = [
+  "src/django_workspaces/__about__.py",
+]
+
+[tool.coverage.paths]
+django_workspaces = [
+  "src/django_workspaces",
+  "*/django-workspaces/src/django_workspaces",
+]
+tests = ["tests", "*/django-workspaces/tests"]
+
+[tool.coverage.report]
+exclude_lines = [
+  "no cov",
+  "if __name__ == .__main__.:",
+  "if TYPE_CHECKING:",
+]
+
+[tool.django-stubs]
+django_settings_module = "demo.settings"
+
+[tool.hatch.version]
+source = "vcs"
+
+[[tool.hatch.envs.all.matrix]]
+python = ["3.10", "3.11", "3.12", "3.13"]
+
+[tool.hatch.envs.default]
+dependencies = [
+  "coverage[toml]>=6.5",
+  "django-stubs",
+  "mypy",
+  "pytest",
+  "pytest-asyncio",
+  "pytest-deadfixtures",
+  "pytest-django",
+]
+
+[tool.hatch.envs.default.scripts]
+types = "mypy --install-types --non-interactive {args:src/django_workspaces tests}"
+test = "pytest {args:tests}"
+test-cov = "coverage run -m pytest {args:tests}"
+cov-report = [
+  "- coverage combine",
+  "coverage report",
+]
+cov = [
+  "test-cov",
+  "cov-report",
+]
+
+[tool.hatch.envs.hatch-test]
+extra-dependencies = ["pytest-asyncio", "pytest-django"]
+
+[tool.hatch.envs.hatch-test.overrides]
+matrix.django.dependencies = [
+  { value = "django>=5.2,<5.3", if = ["5.2"] },
+]
+
+[[tool.hatch.envs.hatch-test.matrix]]
+django = ["5.2"]
+python = ["3.10", "3.11", "3.12", "3.13"]
+
+[tool.hatch.envs.hatch-static-analysis]
+config-path = "none"
+dependencies = ["ruff==0.12.0"]
+
+[tool.mypy]
+strict = true
+plugins = ["mypy_django_plugin.main"]
+
+[tool.pytest.ini_options]
+DJANGO_SETTINGS_MODULE = "demo.settings"
+pythonpath = [".", "src"]
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.format]
+docstring-code-format = true
+
+[tool.ruff.lint]
+select = [
+  "ERA",
+  "ANN",
+  "ASYNC",
+  "S",
+  "BLE",
+  "FBT",
+  "B",
+  "A",
+  "COM818",
+  "C4",
+  "DTZ",
+  "T10",
+  "DJ",
+  "EM",
+  "EXE",
+  "INT",
+  "ISC",
+  "ICN",
+  "LOG",
+  "G",
+  "PIE",
+  "T20",
+  "PYI",
+  "PT",
+  "RSE",
+  "RET",
+  "SLF",
+  "SIM",
+  "SLOT",
+  "TID",
+  "TD",
+  "TC",
+  "PTH",
+  "FLY",
+  "I",
+  "C90",
+  "N",
+  "PERF",
+  "E",
+  "W",
+  "D",
+  "F",
+  "PGH",
+  "PL",
+  "UP",
+  "FURB",
+  "RUF",
+  "TRY",
+]
+
+[tool.ruff.lint.pydocstyle]
+convention = "pep257"
+
+[tool.ruff.lint.flake8-tidy-imports]
+ban-relative-imports = "parents"
+
+[tool.ruff.lint.per-file-ignores]
+"*/models.py" = ["D106"]
+"*/migrations/*.py" = ["D", "RUF012"]
+"tests/*.py" = ["D104", "S101"]
+"demo/*" = ["D"]

django_workspaces-0.0.1a1/src/django_workspaces/__init__.py

@@ -0,0 +1,80 @@
+"""Django reusable app to manage user workspaces.
+
+'Workspace' in this package is a unit of work. Each session always has one
+active workspace. Anything can be added to a workspace.
+"""
+
+from typing import TYPE_CHECKING, Any, cast
+
+import django_stubs_ext
+from django.apps import apps as django_apps
+from django.conf import settings
+from django.http import Http404, HttpRequest
+from django.shortcuts import aget_object_or_404, get_object_or_404
+
+from .signals import workspace_requested
+from .types import _Workspace, _WorkspaceModel
+
+if TYPE_CHECKING:
+    from django.contrib.auth.models import AbstractUser, AnonymousUser
+
+django_stubs_ext.monkeypatch()
+
+__all__ = [
+    "aget_workspace",
+    "get_workspace",
+    "get_workspace_model",
+    "workspace_requested",
+]
+
+SESSION_KEY = "_workspace_id"
+
+
+def get_workspace_model() -> _WorkspaceModel:
+    """Return the workspace model that is active for this project.
+
+    The workspace model defaults to :class:`django_workspaces.models.Workspace`, and can
+    be swapped through the ``WORKSPACE_MODEL`` setting.
+    """
+    workspace_model_name: str = getattr(settings, "WORKSPACE_MODEL", "django_workspaces.Workspace")
+    return django_apps.get_model(workspace_model_name, require_ready=False)
+
+
+def get_workspace(request: HttpRequest) -> _Workspace:
+    """Return the workspace model instance associated with the given request."""
+    Workspace: _WorkspaceModel = get_workspace_model()  # noqa: N806
+    user: AbstractUser | AnonymousUser = request.user
+
+    try:
+        workspace_id = Workspace._meta.pk.to_python(request.session[SESSION_KEY])  # noqa: SLF001
+    except KeyError as exc:
+        responses = workspace_requested.send(Workspace, user=user, request=request)
+        if not responses:
+            msg = "Could not find a workspace"
+            raise Http404(msg) from exc
+
+        _, workspace = cast("tuple[Any, _Workspace]", responses[0])
+    else:
+        workspace = get_object_or_404(Workspace, pk=workspace_id)
+
+    return workspace
+
+
+async def aget_workspace(request: HttpRequest) -> _Workspace:
+    """Async version of :func:`get_workspace`."""
+    Workspace: _WorkspaceModel = get_workspace_model()  # noqa: N806
+    user: AbstractUser | AnonymousUser = await request.auser()
+
+    session_workspace = await request.session.aget(SESSION_KEY)
+    if session_workspace is None:
+        responses = await workspace_requested.asend(Workspace, user=user, request=request)
+        if not responses:
+            msg = "Could not find a workspace"
+            raise Http404(msg)
+
+        _, workspace = cast("tuple[Any, _Workspace]", responses[0])
+    else:
+        workspace_id = Workspace._meta.pk.to_python(session_workspace)  # noqa: SLF001
+        workspace = await aget_object_or_404(Workspace, pk=workspace_id)
+
+    return workspace

django_workspaces-0.0.1a1/src/django_workspaces/_compat.py

@@ -0,0 +1,17 @@
+import sys
+
+if sys.version_info >= (3, 12):
+    from inspect import iscoroutinefunction, markcoroutinefunction
+else:
+    from asgiref.sync import iscoroutinefunction, markcoroutinefunction
+
+if sys.version_info >= (3, 13):
+    from typing import TypeIs
+else:
+    from typing_extensions import TypeIs
+
+__all__ = [
+    "TypeIs",
+    "iscoroutinefunction",
+    "markcoroutinefunction",
+]

django_workspaces-0.0.1a1/src/django_workspaces/apps.py

@@ -0,0 +1,12 @@
+"""Read by Django to configure :mod:`django_workspaces`."""
+
+from django.apps import AppConfig
+from django.utils.translation import gettext_lazy as _
+
+
+class WorkspacesConfig(AppConfig):
+    """:mod:`django_workspaces` app configuration."""
+
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "django_workspaces"
+    verbose_name = _("Workspaces")

django_workspaces-0.0.1a1/src/django_workspaces/middleware.py

@@ -0,0 +1,39 @@
+"""Workspace middlewares."""
+
+from collections.abc import Awaitable, Callable
+from functools import partial
+from typing import cast
+
+from django.core.exceptions import ImproperlyConfigured
+from django.http import HttpResponseBase
+from django.utils.decorators import sync_and_async_middleware
+from django.utils.functional import SimpleLazyObject
+
+from . import aget_workspace, get_workspace
+from ._compat import iscoroutinefunction, markcoroutinefunction
+from .types import HttpRequest, _Workspace
+
+_Middleware = Callable[[HttpRequest], HttpResponseBase] | Callable[[HttpRequest], Awaitable[HttpResponseBase]]
+
+
+@sync_and_async_middleware
+def workspace_middleware(get_response: _Middleware, /) -> _Middleware:
+    """Django middleware to add the current workspace to every request.
+
+    Adds the property `workspace` to use in sync contexts, and the
+    `aworkspace` corourine function for async contexts.
+    """
+
+    def middleware(request: HttpRequest) -> HttpResponseBase:
+        if not hasattr(request, "user"):
+            msg: str = "The workspace middleware requires Django's authentication middleware"
+            raise ImproperlyConfigured(msg)
+
+        request.workspace = cast("_Workspace", SimpleLazyObject(partial(get_workspace, request)))
+        request.aworkspace = partial(aget_workspace, request)
+        return get_response(request)  # type: ignore[return-value]
+
+    if iscoroutinefunction(get_response):
+        middleware = markcoroutinefunction(middleware)
+
+    return middleware

django_workspaces-0.0.1a1/src/django_workspaces/migrations/0001_initial.py

@@ -0,0 +1,29 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name="Workspace",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                (
+                    "name",
+                    models.CharField(
+                        db_comment="Workspace name",
+                        help_text="Required. 255 characters or fewer.",
+                        max_length=255,
+                        verbose_name="name",
+                    ),
+                ),
+            ],
+            options={
+                "abstract": False,
+                "swappable": "WORKSPACE_MODEL",
+            },
+        ),
+    ]

django_workspaces-0.0.1a1/src/django_workspaces/models.py

@@ -0,0 +1,33 @@
+"""Workspace models."""
+
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+from django_stubs_ext.db.models import TypedModelMeta
+
+
+class AbstractWorkspace(models.Model):
+    """Abstract base class implementing a workspace.
+
+    Custom workspace models should inherit from this class.
+    """
+
+    name = models.CharField(
+        _("name"),
+        max_length=255,
+        help_text=_("Required. 255 characters or fewer."),
+        db_comment="Workspace name",
+    )
+
+    class Meta(TypedModelMeta):
+        abstract = True
+
+    def __str__(self) -> str:
+        """Return a string representation of the workspace."""
+        return self.name
+
+
+class Workspace(AbstractWorkspace):
+    """Default workspace model."""
+
+    class Meta(AbstractWorkspace.Meta):
+        swappable = "WORKSPACE_MODEL"

django_workspaces-0.0.1a1/src/django_workspaces/py.typed

@@ -0,0 +1 @@
+PEP-561 marker file

django_workspaces-0.0.1a1/src/django_workspaces/signals.py

@@ -0,0 +1,17 @@
+"""Dispatched signals."""
+
+from django.dispatch import Signal
+
+workspace_requested = Signal()
+"""Dispatched when a workspace is not found in the current session.
+
+This should look up the user's preferences to get the latest or default workspace.
+
+Args:
+    sender: The current workspace model.
+    user: The user requesting a workspace.
+    request: The current request. Optional.
+
+Returns:
+    A workspace instance if could find a default workspace. None otherwise.
+"""

django_workspaces-0.0.1a1/src/django_workspaces/types.py

@@ -0,0 +1,23 @@
+"""Type helpers."""
+
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING, TypeAlias
+
+from django.http import HttpRequest as DjangoHttpRequest
+
+if TYPE_CHECKING:
+    from .models import AbstractWorkspace
+
+_Workspace: TypeAlias = "AbstractWorkspace"
+"""Placeholder type for the current workspace.
+
+The mypy plugin will refine it someday."""
+
+_WorkspaceModel: TypeAlias = type[_Workspace]  # noqa: PYI047
+
+
+class HttpRequest(DjangoHttpRequest):
+    """HTTP request with workspace."""
+
+    workspace: _Workspace
+    aworkspace: Callable[[], Awaitable[_Workspace]]

django_workspaces-0.0.1a1/tests/test_middleware.py

@@ -0,0 +1,119 @@
+"""Tests for workspace_middleware."""
+
+from collections.abc import Awaitable, Callable
+from unittest import mock
+
+import pytest
+from asgiref.sync import async_to_sync
+from django.contrib.auth.models import User
+from django.core.exceptions import ImproperlyConfigured
+from django.http import HttpRequest, HttpResponse
+from django.http.response import HttpResponseBase
+from django.test.client import RequestFactory
+
+from django_workspaces._compat import iscoroutinefunction
+from django_workspaces.middleware import workspace_middleware
+
+
+@pytest.fixture
+def get_response() -> Callable[[HttpRequest], HttpResponseBase]:
+    """Return a dummy sync get_response function."""
+
+    def middleware(request: HttpRequest, /) -> HttpResponse:
+        return HttpResponse()
+
+    return middleware
+
+
+@pytest.fixture
+def get_response_async() -> Callable[[HttpRequest], Awaitable[HttpResponseBase]]:
+    """Return a dummy async get_response function."""
+
+    async def middleware(request: HttpRequest, /) -> HttpResponse:
+        return HttpResponse()
+
+    return middleware
+
+
+def test_sync_middleware_chain(
+    get_response: Callable[[HttpRequest], HttpResponseBase],
+    rf: RequestFactory,
+    admin_user: User,
+) -> None:
+    """Test the sync middleware."""
+    middleware = workspace_middleware(get_response)
+    assert iscoroutinefunction(middleware) is False, "Expected a sync middleware. Got an async one"
+
+    request = rf.get("/")
+    with pytest.raises(ImproperlyConfigured):
+        middleware(request)  # type: ignore[arg-type]
+    assert not hasattr(request, "workspace"), "response should not have a workspace attribute"
+    assert not hasattr(request, "aworkspace"), "response should not have an aworkspace attribute"
+
+    request.user = admin_user
+
+    expected_sync = mock.Mock()
+    expected_async = mock.Mock()
+    with (
+        mock.patch("django_workspaces.middleware.get_workspace", return_value=expected_sync) as mock_get_workspace,
+        mock.patch("django_workspaces.middleware.aget_workspace", return_value=expected_async) as mock_aget_workspace,
+    ):
+        got: HttpResponseBase = middleware(request)  # type: ignore[arg-type, assignment]
+
+    assert isinstance(got, HttpResponseBase), f"Expected a response, got {type(got)}"
+
+    assert hasattr(request, "workspace"), "response should have a workspace attribute"
+    mock_get_workspace.assert_not_called()
+    workspace = request.workspace
+    assert workspace == expected_sync
+    mock_get_workspace.assert_called_once()
+
+    assert hasattr(request, "aworkspace"), "response should have an aworkspace attribute"
+    mock_aget_workspace.assert_not_awaited()
+    workspace = async_to_sync(request.aworkspace)()
+    assert workspace == expected_async
+    mock_aget_workspace.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_async_middleware_chain(
+    get_response_async: Callable[[HttpRequest], Awaitable[HttpResponseBase]],
+    rf: RequestFactory,
+    admin_user: User,
+) -> None:
+    """Test the async middleware."""
+    middleware = workspace_middleware(get_response_async)
+    assert iscoroutinefunction(middleware), "Expected an async middleware. Got a sync one"
+
+    request = rf.get("/")
+    with pytest.raises(ImproperlyConfigured):
+        await middleware(request)  # type: ignore[arg-type]
+    assert not hasattr(request, "workspace"), "response should not have a workspace attribute"
+    assert not hasattr(request, "aworkspace"), "response should not have an aworkspace attribute"
+
+    async def aget_user() -> User:
+        return admin_user
+
+    request.user = admin_user
+    request.auser = aget_user
+    expected_sync = mock.Mock()
+    expected_async = mock.Mock()
+    with (
+        mock.patch("django_workspaces.middleware.get_workspace", return_value=expected_sync) as mock_get_workspace,
+        mock.patch("django_workspaces.middleware.aget_workspace", return_value=expected_async) as mock_aget_workspace,
+    ):
+        got: HttpResponseBase = await middleware(request)  # type: ignore[arg-type]
+
+    assert isinstance(got, HttpResponseBase), f"Expected a response, got {type(got)}"
+
+    assert hasattr(request, "workspace"), "response should have a workspace attribute"
+    mock_get_workspace.assert_not_called()
+    workspace = request.workspace
+    assert workspace == expected_sync
+    mock_get_workspace.assert_called_once()
+
+    assert hasattr(request, "aworkspace"), "response should have an aworkspace attribute"
+    mock_aget_workspace.assert_not_awaited()
+    workspace = await request.aworkspace()
+    assert workspace == expected_async
+    mock_aget_workspace.assert_awaited_once()

django_workspaces-0.0.1a1/tests/test_utils.py

@@ -0,0 +1,239 @@
+"""Tests for module functions."""
+
+from unittest import mock
+
+import pytest
+from asgiref.sync import async_to_sync
+from django.apps import apps
+from django.contrib.auth.models import User
+from django.http import Http404
+from django.test.client import AsyncClient, AsyncRequestFactory, Client, RequestFactory
+from pytest_django.fixtures import SettingsWrapper
+
+from django_workspaces import SESSION_KEY, aget_workspace, get_workspace, get_workspace_model, workspace_requested
+from django_workspaces.models import Workspace
+
+pytestmark = pytest.mark.django_db
+
+
+def test_get_workspace_model_default(settings: SettingsWrapper) -> None:
+    """Test if :func:'`get_workspace_model` defaults to :class:`Workspace`."""
+    del settings.WORKSPACE_MODEL
+
+    got = get_workspace_model()
+
+    assert got is Workspace
+
+
+def test_get_workspace_model_swapped(settings: SettingsWrapper) -> None:
+    """Test if :func:'`get_workspace_model` gets the configured workspace model."""
+    settings.INSTALLED_APPS += ["django.contrib.sites"]
+    settings.WORKSPACE_MODEL = "sites.Site"
+
+    got = get_workspace_model()
+
+    assert got is apps.get_model("sites", "Site")
+
+
+def test_get_workspace_with_session(settings: SettingsWrapper, rf: RequestFactory, client: Client) -> None:
+    """Test if :func:`get_workspace` gets the session workspace."""
+    del settings.WORKSPACE_MODEL
+
+    user = User.objects.create(username="testuser", email="test@example.com", password="testpw")  # noqa: S106
+    client.login(username="testuser", passworkd="testpw")
+    expected: Workspace = Workspace.objects.create(name="test workspace")
+    request = rf.get("/")
+    request.user = user
+    request.session = client.session
+    request.session[SESSION_KEY] = str(expected.pk)
+
+    got = get_workspace(request)
+
+    assert got == expected
+
+
+def test_get_workspace_with_session_non_existing(settings: SettingsWrapper, rf: RequestFactory, client: Client) -> None:
+    """Test if :func:`get_workspace` raises exception when session workspace does not exist."""
+    del settings.WORKSPACE_MODEL
+
+    user = User.objects.create(username="testuser", email="test@example.com", password="testpw")  # noqa: S106
+    client.login(username="testuser", passworkd="testpw")
+    request = rf.get("/")
+    request.user = user
+    request.session = client.session
+    request.session[SESSION_KEY] = "0"
+
+    with pytest.raises(Http404):
+        get_workspace(request)
+
+
+def test_get_workspace_requests_signal(settings: SettingsWrapper, rf: RequestFactory, client: Client) -> None:
+    """Test if :func:`get_workspace` uses requested workspace when there is no workspace in session."""
+    del settings.WORKSPACE_MODEL
+
+    user = User.objects.create(username="testuser", email="test@example.com", password="testpw")  # noqa: S106
+    client.login(username="testuser", passworkd="testpw")
+    expected: Workspace = Workspace.objects.create(name="test workspace")
+    request = rf.get("/")
+    request.user = user
+    request.session = client.session
+    mock_signal = mock.Mock(return_value=expected)
+
+    workspace_requested.connect(mock_signal)
+    try:
+        got = get_workspace(request)
+
+        assert got == expected
+        mock_signal.assert_called_once_with(
+            signal=workspace_requested,
+            sender=Workspace,
+            user=user,
+            request=request,
+        )
+    finally:
+        workspace_requested.disconnect(mock_signal)
+
+
+def test_get_workspace_no_signal(settings: SettingsWrapper, rf: RequestFactory, client: Client) -> None:
+    """Test if :func:`get_workspace` raises exception when there are no signals to respond workspace requests."""
+    del settings.WORKSPACE_MODEL
+
+    user = User.objects.create(username="testuser", email="test@example.com", password="testpw")  # noqa: S106
+    client.login(username="testuser", passworkd="testpw")
+    request = rf.get("/")
+    request.user = user
+    request.session = client.session
+
+    with pytest.raises(Http404):
+        get_workspace(request)
+
+
+def test_get_workspace_requests_signal_none(settings: SettingsWrapper, rf: RequestFactory, client: Client) -> None:
+    """Test if :func:`get_workspace` raises exception when signal return None."""
+    del settings.WORKSPACE_MODEL
+
+    user = User.objects.create(username="testuser", email="test@example.com", password="testpw")  # noqa: S106
+    client.login(username="testuser", passworkd="testpw")
+    request = rf.get("/")
+    request.user = user
+    request.session = client.session
+
+    with pytest.raises(Http404):
+        get_workspace(request)
+
+
+def test_aget_workspace_with_session(
+    settings: SettingsWrapper, async_rf: AsyncRequestFactory, async_client: AsyncClient
+) -> None:
+    """Test if :func:`aget_workspace` gets the session workspace."""
+    del settings.WORKSPACE_MODEL
+
+    user = User.objects.create(username="testuser", email="test@example.com", password="testpw")  # noqa: S106
+    async_to_sync(async_client.alogin)(username="testuser", passworkd="testpw")
+    expected: Workspace = Workspace.objects.create(name="test workspace")
+    request = async_rf.get("/")
+
+    async def auser() -> User:
+        return user
+
+    request.auser = auser
+    request.session = async_client.session
+    request.session[SESSION_KEY] = str(expected.pk)
+
+    got = async_to_sync(aget_workspace)(request)
+
+    assert got == expected
+
+
+def test_aget_workspace_with_session_non_existing(
+    settings: SettingsWrapper, async_rf: AsyncRequestFactory, async_client: AsyncClient
+) -> None:
+    """Test if :func:`aget_workspace` raises exception when session workspace does not exist."""
+    del settings.WORKSPACE_MODEL
+
+    user = User.objects.create(username="testuser", email="test@example.com", password="testpw")  # noqa: S106
+    async_to_sync(async_client.alogin)(username="testuser", passworkd="testpw")
+    request = async_rf.get("/")
+
+    async def auser() -> User:
+        return user
+
+    request.auser = auser
+    request.session = async_client.session
+    request.session[SESSION_KEY] = "0"
+
+    with pytest.raises(Http404):
+        async_to_sync(aget_workspace)(request)
+
+
+def test_aget_workspace_requests_signal(
+    settings: SettingsWrapper, async_rf: AsyncRequestFactory, async_client: AsyncClient
+) -> None:
+    """Test if :func:`aget_workspace` uses requested workspace when there is no workspace in session."""
+    del settings.WORKSPACE_MODEL
+
+    user = User.objects.create(username="testuser", email="test@example.com", password="testpw")  # noqa: S106
+    async_to_sync(async_client.alogin)(username="testuser", passworkd="testpw")
+    expected: Workspace = Workspace.objects.create(name="test workspace")
+    request = async_rf.get("/")
+
+    async def auser() -> User:
+        return user
+
+    request.auser = auser
+    request.session = async_client.session
+    mock_signal = mock.AsyncMock(return_value=expected)
+
+    workspace_requested.connect(mock_signal)
+    try:
+        got = async_to_sync(aget_workspace)(request)
+
+        assert got == expected
+        mock_signal.assert_awaited_once_with(
+            signal=workspace_requested,
+            sender=Workspace,
+            user=user,
+            request=request,
+        )
+    finally:
+        workspace_requested.disconnect(mock_signal)
+
+
+def test_aget_workspace_no_signal(
+    settings: SettingsWrapper, async_rf: AsyncRequestFactory, async_client: AsyncClient
+) -> None:
+    """Test if :func:`aget_workspace` raises exception when there are no signals to respond workspace requests."""
+    del settings.WORKSPACE_MODEL
+
+    user = User.objects.create(username="testuser", email="test@example.com", password="testpw")  # noqa: S106
+    async_to_sync(async_client.alogin)(username="testuser", passworkd="testpw")
+    request = async_rf.get("/")
+
+    async def auser() -> User:
+        return user
+
+    request.auser = auser
+    request.session = async_client.session
+
+    with pytest.raises(Http404):
+        async_to_sync(aget_workspace)(request)
+
+
+def test_aget_workspace_requests_signal_none(
+    settings: SettingsWrapper, async_rf: AsyncRequestFactory, async_client: AsyncClient
+) -> None:
+    """Test if :func:`aget_workspace` raises exception when signal return None."""
+    del settings.WORKSPACE_MODEL
+
+    user = User.objects.create(username="testuser", email="test@example.com", password="testpw")  # noqa: S106
+    async_to_sync(async_client.alogin)(username="testuser", passworkd="testpw")
+    request = async_rf.get("/")
+
+    async def auser() -> User:
+        return user
+
+    request.auser = auser
+    request.session = async_client.session
+
+    with pytest.raises(Http404):
+        async_to_sync(aget_workspace)(request)