nside-wefa 0.1.0__tar.gz

nside_wefa-0.1.0/.coveragerc

@@ -0,0 +1,4 @@
+[run]
+omit =
+    # Omit all tests anywhere from coverage report
+    */tests/*

nside_wefa-0.1.0/.gitignore

@@ -0,0 +1 @@
+.coverage

nside_wefa-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12

nside_wefa-0.1.0/CONTRIBUTE.md

@@ -0,0 +1,357 @@
+# Contributing to N-SIDE WeFa
+
+Thank you for your interest in contributing to N-SIDE WeFa!
+This document provides guidelines and instructions for setting up your development environment and contributing to the project.
+
+## Table of Contents
+
+- [Development Setup](#development-setup)
+- [Project Structure](#project-structure)
+- [Running Tests](#running-tests)
+- [Code Standards](#code-standards)
+- [Contributing Workflow](#contributing-workflow)
+- [Adding New Libraries](#adding-new-libraries)
+- [Documentation](#documentation)
+
+## Development Setup
+
+### Prerequisites
+
+- Python >= 3.12
+- UV package manager (recommended) or pip
+- Git
+
+### Local Development Environment
+
+1. **Clone the repository:**
+   ```bash
+   git clone https://github.com/n-side-dev/wefa.git
+   cd wefa
+   ```
+
+2. **Set up virtual environment with UV (recommended):**
+   ```bash
+   uv venv
+   source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+   ```
+
+   Or with pip:
+   ```bash
+   python -m venv .venv
+   source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+   ```
+
+3. **Install dependencies:**
+   ```bash
+   uv sync --all-extras  # With UV
+   # or
+   pip install -e ".[dev]"  # With pip
+   ```
+
+4. **Set up the test Django project:**
+   ```bash
+   cd django
+   python manage.py migrate
+   ```
+
+### Creating a Test Django Project
+
+To test the library in a separate Django project:
+
+1. **Create a new Django project:**
+   ```bash
+   mkdir test_project
+   cd test_project
+   django-admin startproject myproject .
+   ```
+
+2. **Install nside-wefa in development mode:**
+   ```bash
+   pip install -e /path/to/nside-demo
+   ```
+
+3. **Add to INSTALLED_APPS:**
+   ```python
+   # settings.py
+   INSTALLED_APPS = [
+       'django.contrib.admin',
+       'django.contrib.auth',
+       'django.contrib.contenttypes',
+       'django.contrib.sessions',
+       'django.contrib.messages',
+       'django.contrib.staticfiles',
+       'rest_framework',
+       'rest_framework.authtoken',          # Required for Token authentication
+       'rest_framework_simplejwt',          # Required for JWT authentication
+       'nside_wefa.common',                 # Must come before other nside_wefa apps
+       'nside_wefa.authentication',         # Add the Authentication app
+       'nside_wefa.legal_consent',          # Add the LegalConsent app
+   ]
+   
+   # Configuration
+   NSIDE_WEFA = {
+       'APP_NAME': 'My App',
+       'AUTHENTICATION': {
+         'TYPES': ['TOKEN', 'JWT'],
+       },
+       'LEGAL_CONSENT': {
+         'VERSION': 1,
+         'EXPIRY_LIMIT': 365,
+       }
+   }
+   ```
+
+4. **Run migrations and test:**
+   ```bash
+   python manage.py migrate
+   python manage.py runserver
+   ```
+
+## Project Structure
+
+```
+nside-wefa/
+├── nside_wefa/                 # Main package
+│   ├── __init__.py
+│   ├── authentication/         # Authentication configuration library
+│   │   ├── __init__.py
+│   │   ├── apps.py
+│   │   ├── checks.py
+│   │   ├── constants.py
+│   │   ├── urls.py
+│   │   ├── utils/
+│   │   ├── tests/
+│   │   └── README.md
+│   └── legal_consent/          # Legal Consent library
+│       ├── __init__.py
+│       ├── models/
+│       ├── views.py
+│       ├── serializers.py
+│       ├── urls.py
+│       ├── tests/
+│       └── README.md
+├── pyproject.toml              # Package configuration
+├── README.md                   # Main documentation
+├── CONTRIBUTE.md               # This file
+└── manage.py                   # Django management script (for testing)
+```
+
+## Running Tests
+
+### Full Test Suite
+
+Run all tests from the project root:
+
+```bash
+cd django/nside_wefa
+python manage.py test
+```
+
+### Specific App Tests
+
+Run tests for a specific app:
+
+```bash
+python manage.py test nside_wefa.authentication
+python manage.py test nside_wefa.legal_consent
+```
+
+### Test Categories
+
+Run specific test categories:
+
+```bash
+# Authentication tests
+python manage.py test nside_wefa.authentication.tests
+# Model tests
+python manage.py test nside_wefa.legal_consent.tests.models
+
+# View tests
+python manage.py test nside_wefa.legal_consent.tests.views
+
+# Serializer tests
+python manage.py test nside_wefa.legal_consent.tests.serializers
+
+
+# Migration tests
+python manage.py test nside_wefa.legal_consent.tests.migrations
+```
+
+### Coverage
+
+To run tests with coverage:
+
+```bash
+coverage run --source='.' manage.py test
+coverage report
+coverage html  # Generate HTML coverage report
+```
+
+## Code Standards
+
+### Python Code Style
+
+- Follow PEP 8 guidelines
+- Use meaningful variable and function names
+- Add docstrings to all classes and functions
+- Maximum line length: 88 characters (Black formatter default)
+
+### Django Conventions
+
+- Follow Django's coding style
+- Use Django's built-in features when possible
+- Maintain backward compatibility
+- Write comprehensive tests for all functionality
+
+### Type Hints
+
+Use type hints for all function parameters and return values:
+
+```python
+from typing import Optional
+from django.contrib.auth.models import User
+from nside_wefa.legal_consent.models import LegalConsent
+
+def create_user_agreement(user: User, version: Optional[int] = None) -> LegalConsent:
+    """Create a legal consent for the given user."""
+    # Implementation here
+```
+
+## Contributing Workflow
+
+### 1. Fork and Branch
+
+1. Fork the repository on GitHub
+2. Create a branch (feature/ or bugfix/ or ...):
+   ```bash
+   git checkout -b feature/your-feature-name
+   ```
+
+### 2. Development
+
+1. Make your changes
+2. Write or update tests
+3. Update documentation if necessary
+4. Ensure all tests pass
+
+### 3. Code Quality
+
+Run code quality checks:
+
+```bash
+# Format code
+ruff format .
+
+# Check linting
+ruff check .
+
+# Type checking
+mypy nside_wefa/
+```
+
+### 4. Testing
+
+Before submitting:
+
+```bash
+# Run full test suite
+python manage.py test
+
+# Check test coverage
+coverage run --source='.' manage.py test
+coverage report --fail-under=80
+```
+
+### 5. Submit Pull Request
+
+1. Push your branch to your fork
+2. Create a pull request with:
+   - Clear description of changes
+   - Reference to any related issues
+   - Test results
+   - Updated documentation
+
+## Adding New Libraries
+
+When adding a new library to the nside-wefa package:
+
+### 1. Structure
+
+Create the library structure:
+
+```
+nside_wefa/
+└── your_library/
+    ├── __init__.py
+    ├── apps.py
+    ├── models/
+    ├── views.py
+    ├── serializers.py
+    ├── urls.py
+    ├── tests/
+    └── README.md
+```
+
+### 2. App Configuration
+
+Create an `apps.py` file:
+
+```python
+from django.apps import AppConfig
+
+class YourLibraryConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "nside_wefa.your_library"
+```
+
+### 3. Documentation
+
+Create a comprehensive `README.md` for your library following the LegalConsent library example.
+
+### 4. Tests
+
+Write comprehensive tests covering:
+- Model functionality
+- View behavior
+- Serializer validation
+- Migration operations
+- Integration scenarios
+
+### 5. Update Main README
+
+Add your library to the Libraries section in the main README.md.
+
+## Documentation
+
+### Code Documentation
+
+- Add docstrings to all classes, methods, and functions
+- Use reST-style docstrings (reStructuredText format)
+- Include type hints
+- Document complex business logic
+
+### README Updates
+
+When making changes:
+- Update the relevant library README
+- Update the main README if adding new features
+- Keep examples up to date
+- Update version numbers as needed
+
+### API Documentation
+
+For REST API endpoints:
+- Use DRF's built-in schema generation
+- Add comprehensive docstrings to serializers and views
+- Include usage examples
+
+## Questions and Support
+
+If you have questions or need help:
+
+1. Check existing issues on GitHub
+2. Review the documentation
+3. Create a new issue with detailed information
+4. Tag maintainers if urgent
+
+Thank you for contributing to N-SIDE WeFa!

nside_wefa-0.1.0/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: nside-wefa
+Version: 0.1.0
+Summary: Django library with Legal Consent compliance utilities and reusable apps
+Project-URL: Homepage, https://github.com/n-side-dev/wefa
+Project-URL: Repository, https://github.com/n-side-dev/wefa
+Project-URL: Documentation, https://github.com/n-side-dev/wefa#readme
+Project-URL: Issues, https://github.com/n-side-dev/wefa/issues
+Author-email: N-SIDE <fso@n-side.com>
+License: Apache-2.0
+Keywords: api,compliance,django,gdpr,web
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Requires-Dist: django-cors-headers>=4.9.0
+Requires-Dist: django>=5.2.6
+Requires-Dist: djangorestframework-simplejwt>=5.5.1
+Requires-Dist: djangorestframework>=3.14.0
+Requires-Dist: drf-spectacular>=0.28.0
+Description-Content-Type: text/markdown
+
+# WeFa Django Toolkit
+
+WeFa (Web Factory) delivers a set of modular Django apps that cover recurring web platform concerns such as authentication bootstrapping and legal consent management. The toolkit focuses on convention-over-configuration so new projects can enable production-grade defaults with minimal setup.
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Included Apps](#included-apps)
+- [Quick Start](#quick-start)
+- [Configuration](#configuration)
+- [Requirements](#requirements)
+- [Local Development](#local-development)
+- [Contributing](#contributing)
+- [License](#license)
+- [Project Status](#project-status)
+
+## Features
+
+- Shared utilities that power the higher-level apps (`nside_wefa.common`)
+- Plug-and-play Django REST Framework authentication configuration (token and JWT) (`nside_wefa.authentication`)
+- Legal consent tracking with automatic user onboarding and templated documents (`nside_wefa.legal_consent`)
+- System checks and sensible defaults so configuration mistakes surface early
+
+## Installation
+
+Install the package from PyPI:
+
+```bash
+pip install nside-wefa
+```
+
+Or add it to your dependency file (e.g. `requirements.txt`):
+
+```
+nside-wefa>=0.1.0
+```
+
+## Included Apps
+
+### Common
+
+Foundational helpers shared across the toolkit. You rarely interact with it directly, but it must be installed before the other apps.
+
+### Authentication
+
+Automatically wires Django REST Framework authentication classes, URLs, and dependency checks. See `nside_wefa/authentication/README.md` for the full guide.
+
+### Legal Consent
+
+Tracks acceptance of privacy and terms documents with templating support and REST endpoints. See `nside_wefa/legal_consent/README.md` for details.
+
+## Quick Start
+
+1. Install the package.
+2. Add the apps to `INSTALLED_APPS` (order matters):
+
+   ```python
+   INSTALLED_APPS = [
+       # Django + DRF dependencies...
+       "rest_framework",
+       "rest_framework.authtoken",  # For token auth
+       "rest_framework_simplejwt",  # For JWT auth
+       "nside_wefa.common",
+       "nside_wefa.authentication",
+       "nside_wefa.legal_consent",
+   ]
+   ```
+
+3. Apply migrations:
+
+   ```bash
+   python manage.py migrate
+   ```
+
+4. Expose the URLs you need:
+
+   ```python
+   from django.urls import include, path
+
+   urlpatterns = [
+       # ...your URLs
+       path("auth/", include("nside_wefa.authentication.urls")),
+       path("legal-consent/", include("nside_wefa.legal_consent.urls")),
+   ]
+   ```
+
+## Configuration
+
+The toolkit reads from a namespaced settings dictionary. Start with the minimal configuration below and extend it as needed:
+
+```python
+# settings.py
+NSIDE_WEFA = {
+    "APP_NAME": "My Product",  # Used in legal consent templates
+    "AUTHENTICATION": {
+        "TYPES": ["TOKEN", "JWT"],  # Enable the authentication flows you need
+    },
+    "LEGAL_CONSENT": {
+        "VERSION": 1,
+        "EXPIRY_LIMIT": 365,  # days
+        # "TEMPLATES": BASE_DIR / "templates/legal_consent",  # Optional overrides
+    },
+}
+```
+
+Validation happens through Django system checks. Run `python manage.py check` to surface configuration issues early.
+
+## Requirements
+
+- Python >= 3.12
+- Django >= 5.2.6
+- Django REST Framework >= 3.14.0
+- djangorestframework-simplejwt >= 5.5.1 (if you enable JWT support)
+
+## Local Development
+
+Clone the repository and install the development extras:
+
+```bash
+cd django
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .[dev]
+```
+
+Run the demo project:
+
+```bash
+python manage.py migrate
+python manage.py runserver
+```
+
+Execute the test suite and linters:
+
+```bash
+pytest
+```
+
+## Contributing
+
+We welcome feature ideas, bug reports, and pull requests. Check [CONTRIBUTE](CONTRIBUTE.md) for the current workflow (it will be merged with the repo-wide guidelines soon). Please include documentation updates and tests when relevant.

nside_wefa-0.1.0/README.md

@@ -0,0 +1,142 @@
+# WeFa Django Toolkit
+
+WeFa (Web Factory) delivers a set of modular Django apps that cover recurring web platform concerns such as authentication bootstrapping and legal consent management. The toolkit focuses on convention-over-configuration so new projects can enable production-grade defaults with minimal setup.
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Included Apps](#included-apps)
+- [Quick Start](#quick-start)
+- [Configuration](#configuration)
+- [Requirements](#requirements)
+- [Local Development](#local-development)
+- [Contributing](#contributing)
+- [License](#license)
+- [Project Status](#project-status)
+
+## Features
+
+- Shared utilities that power the higher-level apps (`nside_wefa.common`)
+- Plug-and-play Django REST Framework authentication configuration (token and JWT) (`nside_wefa.authentication`)
+- Legal consent tracking with automatic user onboarding and templated documents (`nside_wefa.legal_consent`)
+- System checks and sensible defaults so configuration mistakes surface early
+
+## Installation
+
+Install the package from PyPI:
+
+```bash
+pip install nside-wefa
+```
+
+Or add it to your dependency file (e.g. `requirements.txt`):
+
+```
+nside-wefa>=0.1.0
+```
+
+## Included Apps
+
+### Common
+
+Foundational helpers shared across the toolkit. You rarely interact with it directly, but it must be installed before the other apps.
+
+### Authentication
+
+Automatically wires Django REST Framework authentication classes, URLs, and dependency checks. See `nside_wefa/authentication/README.md` for the full guide.
+
+### Legal Consent
+
+Tracks acceptance of privacy and terms documents with templating support and REST endpoints. See `nside_wefa/legal_consent/README.md` for details.
+
+## Quick Start
+
+1. Install the package.
+2. Add the apps to `INSTALLED_APPS` (order matters):
+
+   ```python
+   INSTALLED_APPS = [
+       # Django + DRF dependencies...
+       "rest_framework",
+       "rest_framework.authtoken",  # For token auth
+       "rest_framework_simplejwt",  # For JWT auth
+       "nside_wefa.common",
+       "nside_wefa.authentication",
+       "nside_wefa.legal_consent",
+   ]
+   ```
+
+3. Apply migrations:
+
+   ```bash
+   python manage.py migrate
+   ```
+
+4. Expose the URLs you need:
+
+   ```python
+   from django.urls import include, path
+
+   urlpatterns = [
+       # ...your URLs
+       path("auth/", include("nside_wefa.authentication.urls")),
+       path("legal-consent/", include("nside_wefa.legal_consent.urls")),
+   ]
+   ```
+
+## Configuration
+
+The toolkit reads from a namespaced settings dictionary. Start with the minimal configuration below and extend it as needed:
+
+```python
+# settings.py
+NSIDE_WEFA = {
+    "APP_NAME": "My Product",  # Used in legal consent templates
+    "AUTHENTICATION": {
+        "TYPES": ["TOKEN", "JWT"],  # Enable the authentication flows you need
+    },
+    "LEGAL_CONSENT": {
+        "VERSION": 1,
+        "EXPIRY_LIMIT": 365,  # days
+        # "TEMPLATES": BASE_DIR / "templates/legal_consent",  # Optional overrides
+    },
+}
+```
+
+Validation happens through Django system checks. Run `python manage.py check` to surface configuration issues early.
+
+## Requirements
+
+- Python >= 3.12
+- Django >= 5.2.6
+- Django REST Framework >= 3.14.0
+- djangorestframework-simplejwt >= 5.5.1 (if you enable JWT support)
+
+## Local Development
+
+Clone the repository and install the development extras:
+
+```bash
+cd django
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .[dev]
+```
+
+Run the demo project:
+
+```bash
+python manage.py migrate
+python manage.py runserver
+```
+
+Execute the test suite and linters:
+
+```bash
+pytest
+```
+
+## Contributing
+
+We welcome feature ideas, bug reports, and pull requests. Check [CONTRIBUTE](CONTRIBUTE.md) for the current workflow (it will be merged with the repo-wide guidelines soon). Please include documentation updates and tests when relevant.

nside_wefa-0.1.0/conf.py

@@ -0,0 +1,7 @@
+"""
+Sphinx project configuration for the Django package documentation build.
+
+This file exposes minimal settings used by the docs build pipeline and CI.
+"""
+
+project = "N-SIDE WeFa"

nside_wefa-0.1.0/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()