django-multitenant-middleware 0.1.0__tar.gz

django_multitenant_middleware-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vipul Manohar Raut
+
+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_multitenant_middleware-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+recursive-include django-multitenant-middleware *.py

django_multitenant_middleware-0.1.0/PKG-INFO

@@ -0,0 +1,174 @@
+Metadata-Version: 2.4
+Name: django-multitenant-middleware
+Version: 0.1.0
+Summary: HTTP + WebSocket middleware for multi-tenant Django projects
+Author-email: Vipul Manohar Raut <vipulraut38@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Vipul Manohar Raut
+        
+        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.
+Project-URL: Homepage, https://github.com/LazyEpul/django-multitenant-middleware
+Keywords: django,multi-tenant,middleware,channels,asgi
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Django
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Django>=4.2
+Requires-Dist: django-tenants>=3.4
+Dynamic: license-file
+
+# django-multitenant-middleware
+
+`django-multitenant-middleware` is a Django package that provides multi-tenant support for both **HTTP** and **WebSocket (Channels)** requests. It resolves tenants dynamically based on subdomains, hostnames, or custom headers.
+
+---
+
+## Installation
+
+```bash
+pip install django-multitenant-middleware
+```
+
+---
+
+## Settings Configuration (HTTP)
+
+1. Define your tenant model in `settings.py`:
+
+```python
+CHANNELS_MULTITENANT_TENANT_MODEL = "tenants.Client"
+
+# Optional: Custom resolver class and args
+CHANNELS_MULTITENANT_RESOLVER_CLASS = None  # defaults to FlexibleSubdomainTenantResolver
+CHANNELS_MULTITENANT_RESOLVER_ARGS = {"base_domain": BASE_DOMAIN}
+```
+
+2. Add the middleware to your Django `MIDDLEWARE` list:
+
+```python
+MIDDLEWARE = [
+    # Other middleware...
+    "channels_multitenant.http_middleware.TenantHTTPMiddleware",
+]
+```
+
+> The middleware automatically sets `request.tenant` and `request.tenant_context`.
+
+---
+
+## WebSocket Integration (ASGI)
+
+1. In `asgi.py`:
+
+```python
+import os
+import django
+from channels.auth import AuthMiddlewareStack
+from channels.routing import ProtocolTypeRouter, URLRouter
+from django.core.asgi import get_asgi_application
+
+from channels_multitenant.ws_middleware import TenantWebSocketMiddleware
+from channels_multitenant.resolvers import FlexibleSubdomainTenantResolver
+from tenants.models import Client
+from core.websocket.routing import websocket_urlpatterns
+```
+
+2. Setup ASGI:
+
+```python
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "core.settings")
+django.setup()
+django_asgi_app = get_asgi_application()
+```
+
+3. Configure tenant resolver:
+
+```python
+resolver = FlexibleSubdomainTenantResolver(
+    base_domain="app.example.com",  # your base domain
+    separators=("-", ".")
+)
+```
+
+4. Wrap WebSocket routes:
+
+```python
+application = ProtocolTypeRouter({
+    "http": django_asgi_app,
+    "websocket": TenantWebSocketMiddleware(
+        AuthMiddlewareStack(
+            URLRouter(websocket_urlpatterns)
+        ),
+        tenant_model=Client,  # your tenant model
+        resolver=resolver,
+    ),
+})
+```
+
+---
+
+## Tenant Resolvers
+
+* **FlexibleSubdomainTenantResolver**: Extracts tenant from subdomain prefixes
+  Example: `tenant1-app.example.com → tenant1`
+
+* **HeaderTenantResolver**: Extracts tenant from a custom HTTP header
+  Example: `X-Tenant-ID: tenant1 → tenant1`
+
+* **Custom Resolver**: Subclass `BaseTenantResolver` to implement your logic
+
+```python
+from channels_multitenant.resolvers import BaseTenantResolver
+
+class MyCustomResolver(BaseTenantResolver):
+    def resolve(self, scope) -> str | None:
+        # Implement your custom logic
+        return "my_tenant"
+```
+
+---
+
+## TenantFetcher (Optional Helper)
+
+`TenantFetcher` provides async caching for WebSocket tenants:
+
+```python
+from channels_multitenant.tenant_fetcher import TenantFetcher
+from tenants.models import Client
+
+fetcher = TenantFetcher(Client)
+tenant = await fetcher.get_tenant("tenant1")
+```
+
+* Caches tenants (default 5 minutes)
+* Async-ready for Channels
+
+---
+
+## Notes
+
+* Ensure `CHANNELS_MULTITENANT_TENANT_MODEL` points to your tenant model.
+* Missing or invalid settings will raise `ImproperlyConfigured`.
+* Compatible with Django 4.x+ and Channels 3.x+.

django_multitenant_middleware-0.1.0/README.md

@@ -0,0 +1,133 @@
+# django-multitenant-middleware
+
+`django-multitenant-middleware` is a Django package that provides multi-tenant support for both **HTTP** and **WebSocket (Channels)** requests. It resolves tenants dynamically based on subdomains, hostnames, or custom headers.
+
+---
+
+## Installation
+
+```bash
+pip install django-multitenant-middleware
+```
+
+---
+
+## Settings Configuration (HTTP)
+
+1. Define your tenant model in `settings.py`:
+
+```python
+CHANNELS_MULTITENANT_TENANT_MODEL = "tenants.Client"
+
+# Optional: Custom resolver class and args
+CHANNELS_MULTITENANT_RESOLVER_CLASS = None  # defaults to FlexibleSubdomainTenantResolver
+CHANNELS_MULTITENANT_RESOLVER_ARGS = {"base_domain": BASE_DOMAIN}
+```
+
+2. Add the middleware to your Django `MIDDLEWARE` list:
+
+```python
+MIDDLEWARE = [
+    # Other middleware...
+    "channels_multitenant.http_middleware.TenantHTTPMiddleware",
+]
+```
+
+> The middleware automatically sets `request.tenant` and `request.tenant_context`.
+
+---
+
+## WebSocket Integration (ASGI)
+
+1. In `asgi.py`:
+
+```python
+import os
+import django
+from channels.auth import AuthMiddlewareStack
+from channels.routing import ProtocolTypeRouter, URLRouter
+from django.core.asgi import get_asgi_application
+
+from channels_multitenant.ws_middleware import TenantWebSocketMiddleware
+from channels_multitenant.resolvers import FlexibleSubdomainTenantResolver
+from tenants.models import Client
+from core.websocket.routing import websocket_urlpatterns
+```
+
+2. Setup ASGI:
+
+```python
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "core.settings")
+django.setup()
+django_asgi_app = get_asgi_application()
+```
+
+3. Configure tenant resolver:
+
+```python
+resolver = FlexibleSubdomainTenantResolver(
+    base_domain="app.example.com",  # your base domain
+    separators=("-", ".")
+)
+```
+
+4. Wrap WebSocket routes:
+
+```python
+application = ProtocolTypeRouter({
+    "http": django_asgi_app,
+    "websocket": TenantWebSocketMiddleware(
+        AuthMiddlewareStack(
+            URLRouter(websocket_urlpatterns)
+        ),
+        tenant_model=Client,  # your tenant model
+        resolver=resolver,
+    ),
+})
+```
+
+---
+
+## Tenant Resolvers
+
+* **FlexibleSubdomainTenantResolver**: Extracts tenant from subdomain prefixes
+  Example: `tenant1-app.example.com → tenant1`
+
+* **HeaderTenantResolver**: Extracts tenant from a custom HTTP header
+  Example: `X-Tenant-ID: tenant1 → tenant1`
+
+* **Custom Resolver**: Subclass `BaseTenantResolver` to implement your logic
+
+```python
+from channels_multitenant.resolvers import BaseTenantResolver
+
+class MyCustomResolver(BaseTenantResolver):
+    def resolve(self, scope) -> str | None:
+        # Implement your custom logic
+        return "my_tenant"
+```
+
+---
+
+## TenantFetcher (Optional Helper)
+
+`TenantFetcher` provides async caching for WebSocket tenants:
+
+```python
+from channels_multitenant.tenant_fetcher import TenantFetcher
+from tenants.models import Client
+
+fetcher = TenantFetcher(Client)
+tenant = await fetcher.get_tenant("tenant1")
+```
+
+* Caches tenants (default 5 minutes)
+* Async-ready for Channels
+
+---
+
+## Notes
+
+* Ensure `CHANNELS_MULTITENANT_TENANT_MODEL` points to your tenant model.
+* Missing or invalid settings will raise `ImproperlyConfigured`.
+* Compatible with Django 4.x+ and Channels 3.x+.

django_multitenant_middleware-0.1.0/django-multitenant-middleware/__init__.py

@@ -0,0 +1,29 @@
+from channels_multitenant.http_middleware import TenantHTTPMiddleware
+from channels_multitenant.resolvers import (
+    FlexibleSubdomainTenantResolver,
+    HeaderTenantResolver,
+)
+from channels_multitenant.ws_middleware import TenantWebSocketMiddleware
+
+__all__ = [
+    "TenantWebSocketMiddleware",
+    "FlexibleSubdomainTenantResolver",
+    "HeaderTenantResolver",
+    "TenantHTTPMiddleware",
+]
+
+__version__ = "0.1.0"
+
+
+def get_http_middleware(
+    get_response, tenant_model=None, resolver=None, tenant_setter=None
+):
+    """
+    Easy integration: call this from settings.py
+    """
+    return TenantHTTPMiddleware(
+        get_response=get_response,
+        tenant_model=tenant_model,
+        resolver=resolver,
+        tenant_setter=tenant_setter,
+    )

django_multitenant_middleware-0.1.0/django-multitenant-middleware/exceptions.py

@@ -0,0 +1,4 @@
+class TenantNotFound(Exception):
+    """Raised when tenant cannot be resolved."""
+
+    pass

django_multitenant_middleware-0.1.0/django-multitenant-middleware/http_middleware.py

@@ -0,0 +1,93 @@
+from django.apps import apps
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+from django.utils.deprecation import MiddlewareMixin
+from django_tenants.utils import get_public_schema_name, tenant_context
+
+
+class TenantHTTPMiddleware(MiddlewareMixin):
+    """
+    Middleware for resolving tenant in standard Django HTTP requests.
+    Lazily sets tenant or public tenant.
+    """
+
+    def __init__(self, get_response=None):
+        super().__init__(get_response)
+        self.get_response = get_response
+        self._tenant_model = None
+        self._resolver = None
+
+    @property
+    def tenant_model(self):
+        if self._tenant_model is None:
+            # Try to get the model path from settings
+            model_path = getattr(settings, "CHANNELS_MULTITENANT_TENANT_MODEL", None)
+            if model_path is None:
+                raise ImproperlyConfigured(
+                    "You must define CHANNELS_MULTITENANT_TENANT_MODEL in your Django settings!"
+                )
+
+            # If model_path is a string like "app_label.ModelName"
+            if isinstance(model_path, str):
+                try:
+                    app_label, model_name = model_path.split(".")
+                    self._tenant_model = apps.get_model(app_label, model_name)
+                except (ValueError, LookupError) as e:
+                    raise ImproperlyConfigured(
+                        f"Invalid CHANNELS_MULTITENANT_TENANT_MODEL setting: {model_path}. Error: {e}"
+                    )
+            else:
+                # If someone passed the actual model class instead of string
+                self._tenant_model = model_path
+
+        return self._tenant_model
+
+    @property
+    def resolver(self):
+        if self._resolver is None:
+            resolver_class = getattr(
+                settings, "CHANNELS_MULTITENANT_RESOLVER_CLASS", None
+            )
+            resolver_args = getattr(settings, "CHANNELS_MULTITENANT_RESOLVER_ARGS", {})
+            if resolver_class is None:
+                from .resolvers import FlexibleSubdomainTenantResolver
+
+                resolver_class = FlexibleSubdomainTenantResolver
+                resolver_args.setdefault(
+                    "base_domain", getattr(settings, "BASE_DOMAIN", "example.com")
+                )
+            self._resolver = resolver_class(**resolver_args)
+        return self._resolver
+
+    def process_request(self, request):
+        host = request.get_host().split(":")[0]
+        base_domain = getattr(settings, "BASE_DOMAIN", "example.com")
+
+        tenant_name = self.resolver.resolve(host) if self.resolver else None
+        tenant = None
+
+        if tenant_name:
+            try:
+                tenant = self.tenant_model.objects.get(schema_name=tenant_name)
+            except self.tenant_model.DoesNotExist:
+                pass
+
+        # If host is exactly the base domain, use public tenant object
+        if host == base_domain:
+            tenant = self.tenant_model.objects.get(schema_name=get_public_schema_name())
+
+        # Fallback to public schema
+        if tenant:
+            request.tenant = tenant
+            request.tenant_context = tenant_context(tenant)
+            request.tenant_context.__enter__()
+        else:
+            # Should rarely happen, but just in case
+            request.tenant = None
+            request.tenant_context = tenant_context(get_public_schema_name())
+            request.tenant_context.__enter__()
+
+    def process_response(self, request, response):
+        if hasattr(request, "tenant_context"):
+            request.tenant_context.__exit__(None, None, None)
+        return response

django_multitenant_middleware-0.1.0/django-multitenant-middleware/resolvers.py

@@ -0,0 +1,143 @@
+class BaseTenantResolver:
+    """
+    Base class for tenant resolvers.
+
+    A tenant resolver extracts a tenant identifier from an incoming request.
+    The identifier can be derived from different sources such as the host
+    header, specific request headers, or query parameters.
+
+    Subclasses must implement the `resolve()` method.
+    """
+
+    def resolve(self, scope) -> str | None:
+        """
+        Extract tenant identifier from the ASGI scope.
+
+        Parameters
+        ----------
+        scope : dict
+            ASGI scope containing request metadata, including headers.
+
+        Returns
+        -------
+        str | None
+            Resolved tenant identifier, or None if the tenant
+            cannot be determined.
+        """
+        raise NotImplementedError("Subclasses must implement `resolve()`.")
+
+
+class FlexibleSubdomainTenantResolver(BaseTenantResolver):
+    """
+    Resolve tenant from host supporting multiple separator formats.
+
+    This resolver extracts the tenant identifier from the beginning
+    of the host name while supporting multiple separator styles.
+
+    Supported host formats
+    ---------------------
+    Dash separated:
+        tenant1-app.example.com → tenant1
+
+    Dot separated:
+        tenant1.app.example.com → tenant1
+
+    Base domain only:
+        app.example.com → None
+
+    Notes
+    -----
+    - Any port in the host will be automatically removed.
+    - The host must end with the configured `base_domain`.
+    """
+
+    def __init__(self, base_domain: str, separators: tuple[str, ...] = ("-", ".")):
+        self.base_domain = base_domain.lower()
+        self.separators = separators
+
+    def resolve(self, scope) -> str | None:
+        """
+        Extract tenant identifier from the host header.
+
+        Parameters
+        ----------
+        scope : dict or str
+            ASGI scope containing request headers or a host string.
+
+        Returns
+        -------
+        str | None
+            Tenant identifier if found, otherwise None.
+        """
+        # Support plain host string for backward compatibility
+        if isinstance(scope, str):
+            host = scope.split(":")[0].lower()
+        elif isinstance(scope, dict):
+            headers = dict(scope.get("headers", []))
+            host_header = headers.get(b"host")
+            if not host_header:
+                return None
+            host = host_header.decode().split(":")[0].lower()
+        else:
+            return None
+
+        if not host.endswith(self.base_domain):
+            return None
+
+        prefix = host[: -len(self.base_domain)].rstrip(".")
+        if not prefix:
+            return None
+
+        for sep in self.separators:
+            if sep in prefix:
+                return prefix.split(sep)[0]
+
+        return prefix
+
+
+class HeaderTenantResolver(BaseTenantResolver):
+    """
+    Resolve tenant using a request header.
+
+    This resolver extracts the tenant identifier from a specific
+    HTTP header in the request.
+
+    Example
+    -------
+    Request header:
+        X-Tenant-ID: tenant1
+
+    Result:
+        tenant1
+    """
+
+    def __init__(self, header_name: str = "x-tenant-id"):
+        self.header_name = header_name.lower().encode()
+
+    def resolve(self, scope) -> str | None:
+        """
+        Extract tenant identifier from request headers.
+
+        Parameters
+        ----------
+        scope : dict or list of tuples
+            ASGI scope containing request headers or a list of headers.
+
+        Returns
+        -------
+        str | None
+            Tenant identifier if header is present, otherwise None.
+        """
+        headers_dict = {}
+
+        if isinstance(scope, dict):
+            headers_dict = dict(scope.get("headers", []))
+        elif isinstance(scope, (list, tuple)):
+            headers_dict = dict(scope)
+        else:
+            return None
+
+        tenant_header = headers_dict.get(self.header_name)
+        if not tenant_header:
+            return None
+        return tenant_header.decode().strip()

django_multitenant_middleware-0.1.0/django-multitenant-middleware/tenant_fetcher.py

@@ -0,0 +1,29 @@
+from channels.db import database_sync_to_async
+from django.core.cache import cache
+
+
+class TenantFetcher:
+    """
+    Async helper to fetch tenant objects with caching for WebSocket requests.
+    """
+
+    def __init__(self, tenant_model, cache_timeout=300):
+        self.tenant_model = tenant_model
+        self.cache_timeout = cache_timeout
+
+    @database_sync_to_async
+    def get_tenant(self, tenant_name):
+        """
+        Get tenant by schema name, using cache to reduce DB hits.
+        """
+        cache_key = f"ws_tenant_{tenant_name}"
+        tenant = cache.get(cache_key)
+        if tenant:
+            return tenant
+
+        try:
+            tenant = self.tenant_model.objects.get(schema_name=tenant_name)
+            cache.set(cache_key, tenant, self.cache_timeout)
+            return tenant
+        except self.tenant_model.DoesNotExist:
+            return None

django_multitenant_middleware-0.1.0/django-multitenant-middleware/ws_middleware.py

@@ -0,0 +1,42 @@
+from channels.db import database_sync_to_async
+
+
+class TenantWebSocketMiddleware:
+    def __init__(
+        self,
+        app,
+        tenant_model,
+        resolver,
+        tenant_setter=None,
+    ):
+        self.app = app
+        self.tenant_model = tenant_model
+        self.resolver = resolver
+        self.tenant_setter = tenant_setter
+
+    async def __call__(self, scope, receive, send):
+
+        headers = dict(scope["headers"])
+        host = headers.get(b"host", b"").decode()
+
+        tenant_name = self.resolver.resolve(host)
+
+        tenant = None
+
+        if tenant_name:
+            tenant = await self.get_tenant(tenant_name)
+
+        if tenant:
+            scope["tenant"] = tenant
+
+            if self.tenant_setter:
+                await self.tenant_setter(tenant)
+
+        return await self.app(scope, receive, send)
+
+    @database_sync_to_async
+    def get_tenant(self, tenant_name):
+        try:
+            return self.tenant_model.objects.get(schema_name=tenant_name)
+        except self.tenant_model.DoesNotExist:
+            return None

django_multitenant_middleware-0.1.0/django_multitenant_middleware.egg-info/PKG-INFO

@@ -0,0 +1,174 @@
+Metadata-Version: 2.4
+Name: django-multitenant-middleware
+Version: 0.1.0
+Summary: HTTP + WebSocket middleware for multi-tenant Django projects
+Author-email: Vipul Manohar Raut <vipulraut38@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Vipul Manohar Raut
+        
+        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.
+Project-URL: Homepage, https://github.com/LazyEpul/django-multitenant-middleware
+Keywords: django,multi-tenant,middleware,channels,asgi
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Django
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Django>=4.2
+Requires-Dist: django-tenants>=3.4
+Dynamic: license-file
+
+# django-multitenant-middleware
+
+`django-multitenant-middleware` is a Django package that provides multi-tenant support for both **HTTP** and **WebSocket (Channels)** requests. It resolves tenants dynamically based on subdomains, hostnames, or custom headers.
+
+---
+
+## Installation
+
+```bash
+pip install django-multitenant-middleware
+```
+
+---
+
+## Settings Configuration (HTTP)
+
+1. Define your tenant model in `settings.py`:
+
+```python
+CHANNELS_MULTITENANT_TENANT_MODEL = "tenants.Client"
+
+# Optional: Custom resolver class and args
+CHANNELS_MULTITENANT_RESOLVER_CLASS = None  # defaults to FlexibleSubdomainTenantResolver
+CHANNELS_MULTITENANT_RESOLVER_ARGS = {"base_domain": BASE_DOMAIN}
+```
+
+2. Add the middleware to your Django `MIDDLEWARE` list:
+
+```python
+MIDDLEWARE = [
+    # Other middleware...
+    "channels_multitenant.http_middleware.TenantHTTPMiddleware",
+]
+```
+
+> The middleware automatically sets `request.tenant` and `request.tenant_context`.
+
+---
+
+## WebSocket Integration (ASGI)
+
+1. In `asgi.py`:
+
+```python
+import os
+import django
+from channels.auth import AuthMiddlewareStack
+from channels.routing import ProtocolTypeRouter, URLRouter
+from django.core.asgi import get_asgi_application
+
+from channels_multitenant.ws_middleware import TenantWebSocketMiddleware
+from channels_multitenant.resolvers import FlexibleSubdomainTenantResolver
+from tenants.models import Client
+from core.websocket.routing import websocket_urlpatterns
+```
+
+2. Setup ASGI:
+
+```python
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "core.settings")
+django.setup()
+django_asgi_app = get_asgi_application()
+```
+
+3. Configure tenant resolver:
+
+```python
+resolver = FlexibleSubdomainTenantResolver(
+    base_domain="app.example.com",  # your base domain
+    separators=("-", ".")
+)
+```
+
+4. Wrap WebSocket routes:
+
+```python
+application = ProtocolTypeRouter({
+    "http": django_asgi_app,
+    "websocket": TenantWebSocketMiddleware(
+        AuthMiddlewareStack(
+            URLRouter(websocket_urlpatterns)
+        ),
+        tenant_model=Client,  # your tenant model
+        resolver=resolver,
+    ),
+})
+```
+
+---
+
+## Tenant Resolvers
+
+* **FlexibleSubdomainTenantResolver**: Extracts tenant from subdomain prefixes
+  Example: `tenant1-app.example.com → tenant1`
+
+* **HeaderTenantResolver**: Extracts tenant from a custom HTTP header
+  Example: `X-Tenant-ID: tenant1 → tenant1`
+
+* **Custom Resolver**: Subclass `BaseTenantResolver` to implement your logic
+
+```python
+from channels_multitenant.resolvers import BaseTenantResolver
+
+class MyCustomResolver(BaseTenantResolver):
+    def resolve(self, scope) -> str | None:
+        # Implement your custom logic
+        return "my_tenant"
+```
+
+---
+
+## TenantFetcher (Optional Helper)
+
+`TenantFetcher` provides async caching for WebSocket tenants:
+
+```python
+from channels_multitenant.tenant_fetcher import TenantFetcher
+from tenants.models import Client
+
+fetcher = TenantFetcher(Client)
+tenant = await fetcher.get_tenant("tenant1")
+```
+
+* Caches tenants (default 5 minutes)
+* Async-ready for Channels
+
+---
+
+## Notes
+
+* Ensure `CHANNELS_MULTITENANT_TENANT_MODEL` points to your tenant model.
+* Missing or invalid settings will raise `ImproperlyConfigured`.
+* Compatible with Django 4.x+ and Channels 3.x+.

django_multitenant_middleware-0.1.0/django_multitenant_middleware.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+django-multitenant-middleware/__init__.py
+django-multitenant-middleware/exceptions.py
+django-multitenant-middleware/http_middleware.py
+django-multitenant-middleware/resolvers.py
+django-multitenant-middleware/tenant_fetcher.py
+django-multitenant-middleware/ws_middleware.py
+django_multitenant_middleware.egg-info/PKG-INFO
+django_multitenant_middleware.egg-info/SOURCES.txt
+django_multitenant_middleware.egg-info/dependency_links.txt
+django_multitenant_middleware.egg-info/requires.txt
+django_multitenant_middleware.egg-info/top_level.txt
+tests/test_middleware.py

django_multitenant_middleware-0.1.0/django_multitenant_middleware.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

django_multitenant_middleware-0.1.0/django_multitenant_middleware.egg-info/requires.txt

@@ -0,0 +1,2 @@
+Django>=4.2
+django-tenants>=3.4

django_multitenant_middleware-0.1.0/django_multitenant_middleware.egg-info/top_level.txt

@@ -0,0 +1 @@
+

django_multitenant_middleware-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "django-multitenant-middleware"
+version = "0.1.0"
+description = "HTTP + WebSocket middleware for multi-tenant Django projects"
+readme = "README.md"
+requires-python = ">=3.9"
+
+authors = [
+  { name = "Vipul Manohar Raut", email = "vipulraut38@gmail.com" }
+]
+
+license = { file = "LICENSE" }
+
+keywords = ["django", "multi-tenant", "middleware", "channels", "asgi"]
+
+dependencies = [
+  "Django>=4.2",
+  "django-tenants>=3.4"
+]
+
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Framework :: Django",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.12",
+  "Operating System :: OS Independent"
+]
+
+[project.urls]
+Homepage = "https://github.com/LazyEpul/django-multitenant-middleware"

django_multitenant_middleware-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

django_multitenant_middleware-0.1.0/tests/test_middleware.py

@@ -0,0 +1,8 @@
+from channels_multitenant.resolvers import SubdomainTenantResolver
+
+
+def test_resolver():
+
+    resolver = SubdomainTenantResolver("example.com")
+
+    assert resolver.resolve("client1.example.com") == "client1"