va7-core 0.1.0__py3-none-any.whl

va7/conf/__init__.py

@@ -0,0 +1,5 @@
+from va7.core.config import LazySettings
+
+settings = LazySettings()
+
+__all__ = ["settings"]

va7/conf/global_settings.py

@@ -0,0 +1,72 @@
+"""
+VA7 global default settings.
+
+These are the production-ready defaults that ship with VA7.
+Override any of these in your Django settings.py via the VA7 dict.
+
+Example:
+    # settings.py
+    VA7 = {
+        "PROJECT_NAME": "My App",
+        "IDENTITY": {
+            "ROLES": {
+                "ADMIN": {"label": "Admin", "is_admin": True},
+                "MEMBER": {"label": "Member", "is_admin": False},
+            },
+        },
+    }
+"""
+
+# These mirror VA7_DEFAULTS in config.py but are exposed here
+# for documentation and IDE autocomplete purposes.
+
+PROJECT_NAME = "VA7 Project"
+PROJECT_SLUG = "va7-project"
+
+# Core
+CORE_HEALTH_CHECK_PATH = "/health/"
+CORE_SECURITY_HEADERS = True
+
+# Base model
+BASE_MODEL_USE_UUID = True
+BASE_MODEL_SOFT_DELETE = True
+BASE_MODEL_DEFAULT_ORDERING = "-created_at"
+
+# Identity
+IDENTITY_USER_MODEL = None
+IDENTITY_USERNAME_FIELD = "email"
+IDENTITY_ROLES = {}
+IDENTITY_DEFAULT_ROLE = None
+IDENTITY_REGISTRATION_ENABLED = True
+IDENTITY_REQUIRE_EMAIL_VERIFICATION = True
+IDENTITY_OTP_LENGTH = 6
+IDENTITY_OTP_TTL = 900  # 15 minutes
+IDENTITY_OTP_MAX_RESENDS = 3
+IDENTITY_JWT_ACCESS_LIFETIME = 15  # minutes
+IDENTITY_JWT_REFRESH_LIFETIME = 14  # days
+IDENTITY_JWT_CUSTOM_CLAIMS = ["role"]
+IDENTITY_JWT_INCLUDE_USER_IN_RESPONSE = True
+
+# Organizations
+ORG_ENABLED = False
+ORG_MODEL = None
+ORG_SCOPING_FIELD = "organization_id"
+
+# Notifications
+NOTIFY_ENABLED = False
+NOTIFY_CHANNELS = ["IN_APP", "EMAIL"]
+
+# Billing
+BILLING_ENABLED = False
+BILLING_PLANS = {}
+BILLING_DEFAULT_PLAN = None
+BILLING_GATED_URLS = {}
+
+# API
+API_VERSION = "v1"
+API_PAGE_SIZE = 20
+API_THROTTLE_ANON = "100/day"
+API_THROTTLE_USER = "1000/day"
+
+# Storage
+STORAGE_BACKEND = "local"

va7/core/__init__.py

@@ -0,0 +1,48 @@
+"""
+VA7 Core — Foundation layer for Django SaaS applications.
+
+Public API (import directly):
+    from va7.core import BaseModel
+    from va7.core import custom_exception_handler
+    from va7.core import SecurityHeadersMiddleware, HealthCheckMiddleware
+    from va7.core import emit, listen
+
+For utilities, import from submodules:
+    from va7.core.utils import get_env_variable, run_in_background
+    from va7.core.mixins import ChangeTrackingMixin, SoftDeleteAdminMixin
+"""
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # Models
+    "BaseModel",
+    # Exceptions
+    "custom_exception_handler",
+    # Middleware
+    "SecurityHeadersMiddleware",
+    "HealthCheckMiddleware",
+    # Events
+    "emit",
+    "listen",
+]
+
+
+def __getattr__(name):
+    """Lazy imports to avoid Django AppRegistryNotReady at module load time."""
+    _lazy_imports = {
+        "BaseModel": "va7.core.models",
+        "custom_exception_handler": "va7.core.exceptions",
+        "SecurityHeadersMiddleware": "va7.core.middleware",
+        "HealthCheckMiddleware": "va7.core.middleware",
+        "emit": "va7.core.events",
+        "listen": "va7.core.events",
+    }
+
+    if name in _lazy_imports:
+        import importlib
+
+        module = importlib.import_module(_lazy_imports[name])
+        return getattr(module, name)
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

va7/core/apps.py

@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+
+class VA7CoreConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "va7.core"
+    verbose_name = "VA7 Core"
+    label = "va7_core"

va7/core/config.py

@@ -0,0 +1,175 @@
+import copy
+import logging
+import threading
+
+from django.core.exceptions import ImproperlyConfigured
+
+logger = logging.getLogger("va7.core")
+
+# Default configuration — every key is optional with sensible defaults
+VA7_DEFAULTS = {
+    "PROJECT_NAME": "VA7 Project",
+    "PROJECT_SLUG": "va7-project",
+    "CORE": {
+        "HEALTH_CHECK_PATH": "/health/",
+        "SECURITY_HEADERS": True,
+    },
+    "BASE_MODEL": {
+        "USE_UUID": True,
+        "SOFT_DELETE": True,
+        "DEFAULT_ORDERING": "-created_at",
+    },
+    "IDENTITY": {
+        "USER_MODEL": None,
+        "USERNAME_FIELD": "email",
+        "ROLES": {},
+        "DEFAULT_ROLE": None,
+        "REGISTRATION": {
+            "ENABLED": True,
+            "REQUIRE_EMAIL_VERIFICATION": True,
+        },
+        "PASSWORD_RESET": {
+            "OTP_LENGTH": 6,
+            "OTP_TTL": 900,
+            "MAX_RESENDS": 3,
+        },
+        "JWT": {
+            "ACCESS_LIFETIME": 15,
+            "REFRESH_LIFETIME": 14,
+            "CUSTOM_CLAIMS": ["role"],
+            "INCLUDE_USER_IN_RESPONSE": True,
+        },
+    },
+    "ORG": {
+        "ENABLED": False,
+        "MODEL": None,
+        "SCOPING_FIELD": "organization_id",
+    },
+    "NOTIFY": {
+        "ENABLED": False,
+        "CHANNELS": ["IN_APP", "EMAIL"],
+    },
+    "BILLING": {
+        "ENABLED": False,
+        "PLANS": {},
+        "DEFAULT_PLAN": None,
+        "GATED_URLS": {},
+    },
+    "API": {
+        "VERSION": "v1",
+        "PAGE_SIZE": 20,
+        "THROTTLE_RATES": {
+            "anon": "100/day",
+            "user": "1000/day",
+        },
+    },
+    "STORAGE": {
+        "BACKEND": "local",
+    },
+}
+
+
+def _deep_merge(defaults: dict, overrides: dict) -> dict:
+    """Deep merge overrides into defaults. Overrides take precedence."""
+    result = copy.deepcopy(defaults)
+    for key, value in overrides.items():
+        if (
+            key in result
+            and isinstance(result[key], dict)
+            and isinstance(value, dict)
+        ):
+            result[key] = _deep_merge(result[key], value)
+        else:
+            result[key] = copy.deepcopy(value)
+    return result
+
+
+class LazySettings:
+    """
+    Lazy configuration accessor for VA7 settings.
+
+    Follows Django's LazySettings pattern:
+    - Module-level instance (not singleton class)
+    - Thread-safe lazy loading
+    - Attribute access via __getattr__
+    - Dot-notation access via get()
+    - reset() for test isolation
+
+    Usage:
+        from va7.conf import settings
+        roles = settings.AUTH["ROLES"]
+        page_size = settings.get("API.PAGE_SIZE", 20)
+    """
+
+    _wrapped = object()
+
+    def __init__(self):
+        self.__dict__["_wrapped"] = self._wrapped
+        self.__dict__["_lock"] = threading.Lock()
+        self.__dict__["_loaded"] = False
+        self.__dict__["_config"] = None
+
+    def _setup(self):
+        """Load configuration from Django settings, merge with defaults."""
+        from django.conf import settings as django_settings
+
+        user_config = getattr(django_settings, "VA7", {})
+        self.__dict__["_config"] = _deep_merge(VA7_DEFAULTS, user_config)
+        self.__dict__["_loaded"] = True
+        self._validate()
+
+    def _validate(self):
+        """Validate required configuration on startup."""
+        config = self.__dict__["_config"]
+        if config["ORG"]["ENABLED"]:
+            if not config["IDENTITY"]["ROLES"]:
+                raise ImproperlyConfigured(
+                    "VA7: ORG is enabled but IDENTITY.ROLES is not configured. "
+                    "Set VA7['IDENTITY']['ROLES'] in your Django settings."
+                )
+
+    def _ensure_loaded(self):
+        """Thread-safe lazy loading."""
+        if not self.__dict__["_loaded"]:
+            with self.__dict__["_lock"]:
+                if not self.__dict__["_loaded"]:
+                    self._setup()
+
+    def reset(self):
+        """Reset configuration state. For testing only."""
+        with self.__dict__["_lock"]:
+            self.__dict__["_loaded"] = False
+            self.__dict__["_config"] = None
+
+    def get(self, key_path: str, default=None):
+        """Get a nested config value using dot notation.
+
+        Args:
+            key_path: Dot-separated path (e.g., "API.PAGE_SIZE").
+            default: Fallback if key not found.
+
+        Returns:
+            The config value or default.
+        """
+        self._ensure_loaded()
+
+        keys = key_path.split(".")
+        value = self.__dict__["_config"]
+        for key in keys:
+            if isinstance(value, dict) and key in value:
+                value = value[key]
+            else:
+                return default
+        return value
+
+    def __getattr__(self, name):
+        self._ensure_loaded()
+        config = self.__dict__["_config"]
+        if name not in config:
+            raise AttributeError(f"VA7 config has no setting '{name}'")
+        return config[name]
+
+    def __repr__(self):
+        self._ensure_loaded()
+        keys = list(self.__dict__["_config"].keys())
+        return f"<VA7Config [{', '.join(keys)}]>"

va7/core/events.py

@@ -0,0 +1,118 @@
+"""
+VA7 Event Bus — Lightweight synchronous event system for package decoupling.
+
+Usage:
+    from va7.core.events import emit, listen
+
+    # Emit an event
+    emit("user_registered", user=user, request=request)
+
+    # Listen for an event
+    def on_user_registered(sender, **kwargs):
+        user = kwargs["user"]
+        send_welcome_email(user)
+
+    listen("user_registered", on_user_registered)
+
+Design:
+    - Synchronous by default (consistent with Django)
+    - Events are strings (not classes) for simplicity
+    - Listeners receive (sender, **kwargs)
+    - emit() returns False if any listener called stop_propagation()
+    - No priorities, no async, no wildcards (YAGNI for now)
+"""
+
+import logging
+import threading
+from collections import defaultdict
+
+logger = logging.getLogger("va7.core.events")
+
+# Thread-safe storage for listeners
+_listeners: dict[str, list] = defaultdict(list)
+_lock = threading.Lock()
+
+
+def listen(event_name: str, listener=None):
+    """
+    Register a listener for an event.
+
+    Can be used as a decorator:
+        @listen("user_registered")
+        def on_register(sender, **kwargs):
+            ...
+
+    Or called directly:
+        listen("user_registered", my_handler)
+    """
+    if listener is not None:
+        # Direct registration
+        with _lock:
+            _listeners[event_name].append(listener)
+        return listener
+
+    # Decorator usage
+    def decorator(func):
+        with _lock:
+            _listeners[event_name].append(func)
+        return func
+
+    return decorator
+
+
+def unlisten(event_name: str, listener):
+    """Remove a listener from an event."""
+    with _lock:
+        if event_name in _listeners:
+            try:
+                _listeners[event_name].remove(listener)
+            except ValueError:
+                pass
+
+
+def emit(event_name: str, sender=None, **kwargs):
+    """
+    Emit an event to all registered listeners.
+
+    Listeners are called synchronously in registration order.
+    Each listener receives (sender, **kwargs).
+
+    Returns True if all listeners ran, False if propagation was stopped.
+    """
+    with _lock:
+        # Copy the list to avoid issues if listeners modify it
+        current_listeners = list(_listeners.get(event_name, []))
+
+    for listener in current_listeners:
+        try:
+            result = listener(sender, **kwargs)
+            if result is False:
+                return False
+        except Exception:
+            logger.exception(
+                "Event listener %s failed for event '%s'",
+                listener.__name__ if hasattr(listener, "__name__") else str(listener),
+                event_name,
+            )
+
+    return True
+
+
+def clear(event_name: str = None):
+    """
+    Remove all listeners. Primarily for testing.
+
+    If event_name is given, clear only that event's listeners.
+    Otherwise, clear everything.
+    """
+    with _lock:
+        if event_name:
+            _listeners.pop(event_name, None)
+        else:
+            _listeners.clear()
+
+
+def get_listeners(event_name: str) -> list:
+    """Return a copy of the listeners for an event (for testing/introspection)."""
+    with _lock:
+        return list(_listeners.get(event_name, []))

va7/core/exceptions.py

@@ -0,0 +1,50 @@
+import logging
+
+from rest_framework.views import exception_handler
+
+logger = logging.getLogger("va7.core")
+
+
+def custom_exception_handler(exc, context):
+    """
+    DRF exception handler with standardized error format.
+
+    Response format:
+        {
+            "success": false,
+            "message": "An error occurred.",
+            "errors": {"field": ["error messages"]}
+        }
+
+    Combines:
+    - Standardized response format (Triscaleon pattern)
+    - Exception logging (PGPulse pattern)
+    - Critical logging for 500-level errors
+    """
+    view_name = getattr(context.get("view"), "__class__", type(None)).__name__
+    logger.error("API Exception in %s: %s", view_name, exc, exc_info=True)
+
+    response = exception_handler(exc, context)
+
+    if response is None:
+        logger.critical("Unhandled exception in %s: %s", view_name, exc, exc_info=True)
+        return None
+
+    errors = response.data
+
+    # Normalize error format
+    if isinstance(errors, list):
+        errors = {"non_field_errors": errors}
+    elif isinstance(errors, dict) and "detail" in errors:
+        errors = {"non_field_errors": [errors["detail"]]}
+
+    response.data = {
+        "success": False,
+        "message": "An error occurred.",
+        "errors": errors,
+    }
+
+    if response.status_code >= 500:
+        logger.critical("Server error in %s: %s", view_name, exc, exc_info=True)
+
+    return response

va7/core/middleware.py

@@ -0,0 +1,78 @@
+import logging
+
+from django.http import JsonResponse
+
+logger = logging.getLogger("va7.core.middleware")
+
+
+class SecurityHeadersMiddleware:
+    """
+    Adds security headers to all responses.
+
+    Override CSP and other headers in your project's middleware
+    by subclassing or placing your middleware after VA7's.
+    """
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        response = self.get_response(request)
+        response["X-Content-Type-Options"] = "nosniff"
+        response["X-XSS-Protection"] = "1; mode=block"
+        response["Referrer-Policy"] = "strict-origin-when-cross-origin"
+        response["Permissions-Policy"] = "camera=(), microphone=(), geolocation=()"
+        response["Content-Security-Policy"] = (
+            "default-src 'self'; "
+            "script-src 'self' 'unsafe-inline' 'unsafe-eval'; "
+            "style-src 'self' 'unsafe-inline'; "
+            "img-src 'self' data: https: blob:; "
+            "connect-src 'self' https: wss:; "
+            "frame-ancestors 'none';"
+        )
+        # Remove Server header if present
+        if "Server" in response:
+            del response["Server"]
+        return response
+
+
+class HealthCheckMiddleware:
+    """
+    Returns 200 OK for health check endpoints before ALLOWED_HOSTS validation.
+
+    Prevents 400 errors from load balancers and deployment platforms
+    (Render, Railway, Fly.io, etc.) that ping /health/ before the app is ready.
+
+    Configure the health check path via VA7["CORE"]["HEALTH_CHECK_PATH"]
+    or default to both /health/ and /api/health/.
+    """
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        if request.path in ("/health/", "/api/health/"):
+            return JsonResponse({"status": "ok"})
+        return self.get_response(request)
+
+
+class TrueClientIPMiddleware:
+    """
+    Extracts real client IP from X-Forwarded-For / X-Real-IP headers.
+
+    For more advanced IP detection (e.g., checking trusted proxies),
+    install django-ipware and use it directly.
+    """
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        x_forwarded_for = request.META.get("HTTP_X_FORWARDED_FOR")
+        if x_forwarded_for:
+            request.META["REMOTE_ADDR"] = x_forwarded_for.split(",")[0].strip()
+        else:
+            x_real_ip = request.META.get("HTTP_X_REAL_IP")
+            if x_real_ip:
+                request.META["REMOTE_ADDR"] = x_real_ip
+        return self.get_response(request)

va7/core/mixins.py

@@ -0,0 +1,103 @@
+"""
+VA7 Model Mixins — Optional reusable model behaviors.
+
+These mixins complement BaseModel by adding optional fields and admin support.
+Projects opt-in by using the mixin, not by configuring BaseModel.
+"""
+
+from django.conf import settings
+from django.contrib import admin
+from django.db import models
+
+
+class ChangeTrackingMixin(models.Model):
+    """
+    Optional mixin to track who created and last modified a record.
+
+    Usage:
+        class Article(BaseModel, ChangeTrackingMixin):
+            title = models.CharField(max_length=255)
+
+            def save(self, *args, **kwargs):
+                user = kwargs.pop("user", None)
+                if user:
+                    if not self.pk:
+                        self.created_by = user
+                    self.updated_by = user
+                super().save(*args, **kwargs)
+
+    Or set fields directly:
+        article.created_by = user
+        article.updated_by = user
+        article.save()
+
+    This mixin provides the fields only. Population is the project's responsibility.
+    """
+
+    created_by = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="%(class)s_created",
+    )
+    updated_by = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="%(class)s_updated",
+    )
+
+    class Meta:
+        abstract = True
+
+
+class SoftDeleteAdminMixin(admin.ModelAdmin):
+    """
+    Admin mixin that shows soft-deleted objects and provides restore actions.
+
+    Usage:
+        @admin.register(Article)
+        class ArticleAdmin(SoftDeleteAdminMixin, admin.ModelAdmin):
+            list_display = ["title", "is_deleted"]
+
+    Features:
+        - Shows is_deleted in list display
+        - Filter by deletion status
+        - Restore action for soft-deleted objects
+    """
+
+    def get_queryset(self, request):
+        """Use all_with_deleted to show soft-deleted objects in admin."""
+        qs = super().get_queryset(request)
+        if hasattr(qs, "all_with_deleted"):
+            return qs.all_with_deleted.all()
+        return qs
+
+    def get_list_filter(self, request):
+        """Add is_deleted to list filters if not already present."""
+        filters = list(super().get_list_filter(request))
+        if "is_deleted" not in filters:
+            filters.append("is_deleted")
+        return filters
+
+    @admin.action(description="Restore selected items")
+    def restore_selected(self, request, queryset):
+        """Restore soft-deleted objects."""
+        count = 0
+        for obj in queryset.filter(is_deleted=True):
+            obj.restore()
+            count += 1
+        self.message_user(request, f"Restored {count} item(s).")
+
+    def get_actions(self, request):
+        """Add restore action for admin."""
+        actions = super().get_actions(request)
+        if "restore_selected" not in actions:
+            actions["restore_selected"] = (
+                self.restore_selected,
+                "restore_selected",
+                "Restore selected items",
+            )
+        return actions

va7/core/models.py

@@ -0,0 +1,70 @@
+import uuid
+
+from django.db import models
+
+
+class SoftDeleteManager(models.Manager):
+    """Manager that excludes soft-deleted objects by default."""
+
+    def get_queryset(self):
+        return super().get_queryset().filter(is_deleted=False)
+
+
+class BaseModel(models.Model):
+    """
+    Abstract base model for all VA7 models.
+
+    Provides:
+    - UUID primary key
+    - created_at / updated_at timestamps
+    - Soft delete (is_deleted flag + SoftDeleteManager)
+
+    Usage:
+        class MyModel(BaseModel):
+            name = models.CharField(max_length=255)
+
+        # Default queryset excludes soft-deleted
+        MyModel.objects.all()
+
+        # Include soft-deleted
+        MyModel.all_with_deleted.all()
+
+        # Soft delete
+        obj.soft_delete()
+
+        # Restore
+        obj.restore()
+    """
+
+    id = models.UUIDField(
+        primary_key=True,
+        default=uuid.uuid4,
+        editable=False,
+    )
+    created_at = models.DateTimeField(auto_now_add=True, db_index=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    is_deleted = models.BooleanField(default=False, db_index=True)
+
+    objects = SoftDeleteManager()
+    all_with_deleted = models.Manager()
+
+    class Meta:
+        abstract = True
+        ordering = ["-created_at"]
+
+    def soft_delete(self):
+        """Soft delete — marks as deleted without removing the row."""
+        self.is_deleted = True
+        self.save(update_fields=["is_deleted", "updated_at"])
+
+    def hard_delete(self):
+        """Permanent delete — use with caution."""
+        return super().delete()
+
+    def restore(self):
+        """Restore a soft-deleted object."""
+        self.is_deleted = False
+        self.save(update_fields=["is_deleted", "updated_at"])
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__} {self.pk}>"

va7/core/utils.py

@@ -0,0 +1,92 @@
+import logging
+import os
+import threading
+from functools import wraps
+
+from django.core.exceptions import ImproperlyConfigured
+
+logger = logging.getLogger("va7.core")
+
+
+def is_truthy(value: str | None) -> bool:
+    """Check if a string value represents a truthy boolean.
+
+    Returns True for: 'true', '1', 't', 'yes', 'on' (case-insensitive).
+    """
+    return (value or "").lower() in ("true", "1", "t", "yes", "on")
+
+
+def get_env_variable(var_name: str, default=None, required_in_prod: bool = False):
+    """
+    Get an environment variable with fallback and production validation.
+
+    Args:
+        var_name: Environment variable name.
+        default: Fallback value if not set.
+        required_in_prod: If True, raises ImproperlyConfigured in production.
+
+    Returns:
+        The environment variable value or default.
+
+    Raises:
+        ImproperlyConfigured: If required in production and not set.
+    """
+    value = os.getenv(var_name, default)
+
+    from django.conf import settings as django_settings
+
+    is_prod = not getattr(django_settings, "DEBUG", False)
+
+    if is_prod and required_in_prod and (value is None or value == default):
+        raise ImproperlyConfigured(
+            f"VA7: Set the {var_name} environment variable in production."
+        )
+
+    return value
+
+
+def run_in_background(func, *args, **kwargs):
+    """
+    Fire-and-forget background task using threading.
+
+    Ensures DB connections are cleaned up after the thread completes.
+    Use for lightweight tasks (emails, notifications).
+    For heavy workloads, use Celery (va7-tasks).
+
+    Returns:
+        The started Thread instance.
+    """
+
+    def _target():
+        try:
+            func(*args, **kwargs)
+        except Exception:
+            logger.exception("Background task failed: %s", func.__name__)
+        finally:
+            from django import db
+
+            db.connections.close_all()
+
+    thread = threading.Thread(target=_target, daemon=True)
+    thread.start()
+    return thread
+
+
+def deprecated(message: str):
+    """Decorator to mark functions as deprecated with a migration message."""
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            import warnings
+
+            warnings.warn(
+                f"{func.__name__} is deprecated. {message}",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

va7_core-0.1.0.dist-info/METADATA

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: va7-core
+Version: 0.1.0
+Summary: VA7 Framework — Foundation layer for Django SaaS applications
+Project-URL: Homepage, https://github.com/Vishal-2209/va7
+Project-URL: Repository, https://github.com/Vishal-2209/va7
+Author: Vishal Aidasani
+License-Expression: MIT
+Keywords: base-model,django,framework,middleware,saas
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 6.0
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Requires-Dist: dj-database-url>=2.0
+Requires-Dist: django<7.0,>=5.1
+Requires-Dist: djangorestframework>=3.15
+Requires-Dist: python-dotenv>=1.0
+Provides-Extra: dev
+Requires-Dist: pytest-django>=4.8; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# VA7 Core
+
+Foundation layer for Django SaaS applications.
+
+## Installation
+
+```bash
+pip install va7-core
+```
+
+## Quick Start
+
+```python
+# settings.py
+INSTALLED_APPS = [
+    ...
+    "va7.core",
+]
+
+MIDDLEWARE = [
+    "va7.core.middleware.SecurityHeadersMiddleware",
+    "va7.core.middleware.HealthCheckMiddleware",
+    # "va7.core.middleware.TrueClientIPMiddleware",  # Optional
+]
+
+REST_FRAMEWORK = {
+    "EXCEPTION_HANDLER": "va7.core.exceptions.custom_exception_handler",
+}
+```
+
+## What's Included
+
+- **BaseModel** — UUID PKs, timestamps, soft-delete
+- **Event Bus** — `emit()`, `listen()` for cross-package decoupling
+- **Exception Handler** — Standardized DRF error responses
+- **Middleware** — Security headers, health check, client IP
+- **Config** — Django-style lazy settings with deep merge
+- **Mixins** — Change tracking, soft-delete admin
+
+## Project Structure
+
+```
+va7-core/
+├── pyproject.toml
+├── va7/
+│   ├── core/
+│   │   ├── __init__.py       # Public API (lazy imports)
+│   │   ├── models.py         # BaseModel, SoftDeleteManager
+│   │   ├── events.py         # Event bus (emit, listen, unlisten)
+│   │   ├── exceptions.py     # custom_exception_handler
+│   │   ├── middleware.py      # SecurityHeaders, HealthCheck, ClientIP
+│   │   ├── mixins.py         # ChangeTrackingMixin, SoftDeleteAdminMixin
+│   │   ├── utils.py          # is_truthy, get_env_variable, run_in_background
+│   │   └── config.py         # LazySettings, VA7_DEFAULTS
+│   └── conf/
+│       ├── __init__.py       # settings = LazySettings()
+│       └── global_settings.py # Documented defaults
+└── tests/
+    ├── test_config.py
+    ├── test_events.py
+    ├── test_exceptions.py
+    ├── test_middleware.py
+    ├── test_mixins.py
+    └── test_models.py
+```
+
+## Configuration
+
+All configuration is optional with sensible defaults. Override in `settings.py`:
+
+```python
+VA7 = {
+    "PROJECT_NAME": "My SaaS",
+    "IDENTITY": {
+        "ROLES": {
+            "ADMIN": {"label": "Admin", "is_admin": True},
+            "MEMBER": {"label": "Member", "is_admin": False},
+        },
+    },
+}
+```
+
+Access configuration:
+
+```python
+from va7.conf import settings
+
+# Attribute access
+page_size = settings.API["PAGE_SIZE"]
+
+# Dot notation
+page_size = settings.get("API.PAGE_SIZE", 20)
+```
+
+## Testing
+
+```bash
+pip install -e "packages/va7-core[dev]"
+pytest tests/ -v
+```

va7_core-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+va7/conf/__init__.py,sha256=_GpFv0snhf8oLDR3aJJEqpiQDNsKDQhDTHlz2muki7s,92
+va7/conf/global_settings.py,sha256=f12tOggAzBfza3nQRKqPlzA4fBonw7tFNQ_k_4hpxaw,1688
+va7/core/__init__.py,sha256=Wip3IigDK6swBr5fEfG1iRgSiyA4v6NhJ-L6sQ0R5yc,1364
+va7/core/apps.py,sha256=tpuq_i8tY0m9MGjIn2mWzSooPbaoLTKBZOkqKzSnlEM,200
+va7/core/config.py,sha256=qGYfrOHeNmwoXGbl14BbRCTfOOnFAVN0nzuIgDDJLXI,5046
+va7/core/events.py,sha256=mFA-fmgHI4crOwQfgr2Grr5f7L48gWIo2pNoq39uX5A,3185
+va7/core/exceptions.py,sha256=42hkDOJ7LELA-clo23OXa5fNGHQngVbWz7RiiTkk7AY,1403
+va7/core/middleware.py,sha256=hBILkEgSov19qEBUlDNUBKktmQ29VgEUwFlwY3POoAA,2608
+va7/core/mixins.py,sha256=gVtjm5fL9ZkM1isEbLZXtAHIgD04nlDjfXq3dCwSRf4,3168
+va7/core/models.py,sha256=-j2bfetr8js86XJ8-L7CJhx5PetnruNbX2TtTKZncZ8,1815
+va7/core/utils.py,sha256=clR7AkIcTYV3UWnIhRltOhZyKHJuekdbmRRPd3yLkwo,2471
+va7_core-0.1.0.dist-info/METADATA,sha256=B6kX3pDncmYkgPy9GMJXNKqGzezQtmZoaFswpk4kbHg,3629
+va7_core-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+va7_core-0.1.0.dist-info/RECORD,,

va7_core-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any