oxutils 0.1.2__py3-none-any.whl → 0.1.5__py3-none-any.whl

oxutils/pdf/utils.py

@@ -0,0 +1,94 @@
+import logging
+import mimetypes
+import os
+from functools import lru_cache
+from pathlib import Path
+from urllib.parse import urlparse
+
+import weasyprint
+
+from django.conf import settings
+from django.contrib.staticfiles.finders import find
+from django.contrib.staticfiles.storage import staticfiles_storage
+from django.core.files.storage import default_storage
+from django.urls import get_script_prefix
+
+
+log = logging.getLogger(__name__)
+
+
+@lru_cache(maxsize=None)
+def get_reversed_hashed_files():
+    return {v: k for k, v in staticfiles_storage.hashed_files.items()}
+
+
+def django_url_fetcher(url, *args, **kwargs):
+    # attempt to load file:// paths to Django MEDIA or STATIC files directly from disk
+    if url.startswith('file:'):
+        log.debug('Attempt to fetch from %s', url)
+        mime_type, encoding = mimetypes.guess_type(url)
+        url_path = urlparse(url).path
+        data = {
+            'mime_type': mime_type,
+            'encoding': encoding,
+            'filename': Path(url_path).name,
+        }
+
+        default_media_url = settings.MEDIA_URL in ('', get_script_prefix())
+        if not default_media_url and url_path.startswith(settings.MEDIA_URL):
+            log.debug('URL contains MEDIA_URL (%s)', settings.MEDIA_URL)
+            cleaned_media_root = str(settings.MEDIA_ROOT)
+            if not cleaned_media_root.endswith('/'):
+                cleaned_media_root += '/'
+            absolute_path = url_path.replace(settings.MEDIA_URL, cleaned_media_root, 1)
+            log.debug('Cleaned path: %s', absolute_path)
+            data['file_obj'] = default_storage.open(absolute_path, 'rb')
+            data['redirected_url'] = 'file://' + absolute_path
+            return data
+
+        # path looks like a static file based on configured STATIC_URL
+        elif settings.STATIC_URL and url_path.startswith(settings.STATIC_URL):
+            log.debug('URL contains STATIC_URL (%s)', settings.STATIC_URL)
+            # strip the STATIC_URL prefix to get the relative filesystem path
+            relative_path = url_path.replace(settings.STATIC_URL, '', 1)
+            # detect hashed files storage and get path with un-hashed filename
+            if not settings.DEBUG and hasattr(staticfiles_storage, 'hashed_files'):
+                log.debug('Hashed static files storage detected')
+                relative_path = get_reversed_hashed_files()[relative_path]
+                data['filename'] = Path(relative_path).name
+            log.debug('Cleaned path: %s', relative_path)
+            # find the absolute path using the static file finders
+            absolute_path = find(relative_path)
+            log.debug('Static file finder returned: %s', absolute_path)
+            if absolute_path:
+                log.debug('Loading static file: %s', absolute_path)
+                data['file_obj'] = open(absolute_path, 'rb')  # noqa: PTH123
+                data['redirected_url'] = 'file://' + absolute_path
+                return data
+
+    # Fall back to weasyprint default fetcher for http/s: and file: paths
+    # that did not match MEDIA_URL or STATIC_URL.
+    log.debug('Forwarding to weasyprint.default_url_fetcher: %s', url)
+    return weasyprint.default_url_fetcher(url, *args, **kwargs)
+
+
+def get_stylesheet_path(relative_path):
+    if settings.DEBUG:
+        path = find(relative_path)
+        if path:
+            return path
+    print('Le DEBUG est False')
+    static_root_path = os.path.join(settings.STATIC_ROOT, relative_path)
+    if os.path.exists(static_root_path):
+        return static_root_path
+    
+    return None
+
+
+def get_stylesheets(*relative_paths):
+    stylesheets = []
+    for path in relative_paths:
+        resolved = get_stylesheet_path(path)
+        if resolved:
+            stylesheets.append(resolved)
+    return stylesheets

oxutils/pdf/views.py

@@ -0,0 +1,208 @@
+import weasyprint
+
+from django.conf import settings
+from django.template.response import TemplateResponse
+from django.views.generic.base import ContextMixin, TemplateResponseMixin, View
+
+from oxutils.pdf.utils import django_url_fetcher
+
+
+class WeasyTemplateResponse(TemplateResponse):
+    def __init__(
+            self,
+            request,
+            template,
+            context=None,
+            content_type=None,
+            status=None,
+            charset=None,
+            using=None,
+            headers=None,
+            filename=None,
+            attachment=True,
+            stylesheets=None,
+            options=None,
+        ):
+        """
+        An HTTP response class with template and context rendered to a PDF document.
+
+        Django TemplateResponse arguments:
+
+        :param request: the request object
+        :param template: template to use to render the response
+        :param context: context to use to render the response
+        :param content_type: content type of the response (default: 'application/pdf')
+        :param status: status code of the response (default: 200)
+        :param charset: character set of the response (default: settings.DEFAULT_CHARSET)
+        :param using: template engine to use (default: 'django')
+        :param headers: dictionary of headers to use in the response
+
+        WeasyPrint specific arguments:
+
+        :param filename: set `Content-Disposition` to use this filename
+        :param attachment: set `Content-Disposition` 'attachment';
+            A `filename` must be given to enable this even if set to `True`.
+            (default: `True`)
+        :param stylesheets: list of additional stylesheets
+        :param options: dictionary of options passed to WeasyPrint
+        """
+        self._stylesheets = stylesheets or []
+        self._options = options.copy() if options else {}
+
+        kwargs = dict(
+            context=context,
+            content_type=content_type or WeasyTemplateResponseMixin.content_type,
+            status=status,
+            charset=charset,
+            using=using,
+            headers=headers,
+        )
+        super().__init__(request, template, **kwargs)
+
+        if filename:
+            display = 'attachment' if attachment else 'inline'
+            self['Content-Disposition'] = f'{display};filename="{filename}"'
+
+    def get_base_url(self):
+        """
+        Determine base URL to fetch CSS or other files referenced with relative
+        paths in the HTML files using the `WEASYPRINT_BASEURL` setting or
+        fall back to using the root path of the URL used in the request.
+        """
+        return getattr(
+            settings, 'WEASYPRINT_BASEURL',
+            self._request.build_absolute_uri('/')
+        )
+
+    def get_url_fetcher(self):
+        """
+        Determine the URL fetcher to fetch CSS, images, fonts, etc. from.
+        """
+        return django_url_fetcher
+
+    def get_font_config(self):
+        """
+        A FreeType font configuration to handle @font-config rules.
+        """
+        return weasyprint.text.fonts.FontConfiguration()
+
+    def get_css(self, base_url, url_fetcher, font_config):
+        """
+        Load additional stylesheets.
+        """
+        return [
+            weasyprint.CSS(
+                value,
+                base_url=base_url,
+                url_fetcher=url_fetcher,
+                font_config=font_config,
+            )
+            for value
+            in self._stylesheets
+        ]
+
+    def get_document(self):
+        """
+        Returns a :class:`~document.Document` object which provides
+        access to individual pages and various meta-data.
+
+        See :meth:`weasyprint.HTML.render` and
+        :meth:`weasyprint.document.Document.write_pdf` on how to generate a
+        PDF file.
+        """
+        base_url = self.get_base_url()
+        url_fetcher = self.get_url_fetcher()
+        font_config = self.get_font_config()
+
+        html = weasyprint.HTML(
+            string=super().rendered_content,
+            base_url=base_url,
+            url_fetcher=url_fetcher,
+        )
+
+        self._options.setdefault(
+            'stylesheets',
+            self.get_css(base_url, url_fetcher, font_config),
+        )
+
+        return html.render(
+            font_config=font_config,
+            **self._options,
+        )
+
+    @property
+    def rendered_content(self):
+        """
+        Returns rendered PDF pages.
+        """
+        document = self.get_document()
+        return document.write_pdf(**self._options)
+
+
+class WeasyTemplateResponseMixin(TemplateResponseMixin):
+    """
+    Mixin for a CBV creating a ``WeasyTemplateResponse`` using the configured template.
+    """
+    response_class = WeasyTemplateResponse
+    content_type = 'application/pdf'
+    pdf_filename = None
+    pdf_attachment = True
+    pdf_stylesheets = []
+    pdf_options = {}
+
+    def get_pdf_filename(self):
+        """
+        Returns :attr:`pdf_filename` value by default.
+
+        If left blank the browser will display the PDF inline.
+        Otherwise it will pop up the "Save as.." dialog.
+
+        :rtype: :func:`str`
+        """
+        return self.pdf_filename
+
+    def get_pdf_stylesheets(self):
+        """
+        Returns a list of stylesheet filenames to use when rendering.
+
+        :rtype: :func:`list`
+        """
+        return self.pdf_stylesheets
+
+    def get_pdf_options(self):
+        """
+        Returns dictionary of WeasyPrint options.
+        """
+        return self.pdf_options
+
+    def render_to_response(self, context, **response_kwargs):
+        """
+        Renders PDF document and prepares response by calling on
+        :attr:`response_class` (default: :class:`WeasyTemplateResponse`).
+
+        :returns: Django HTTP response
+        :rtype: :class:`django.http.HttpResponse`
+        """
+        response_kwargs.update({
+            'attachment': self.pdf_attachment,
+            'filename': self.get_pdf_filename(),
+            'stylesheets': self.get_pdf_stylesheets(),
+            'options': self.get_pdf_options(),
+        })
+        return super().render_to_response(
+            context, **response_kwargs
+        )
+
+
+class WeasyTemplateView(WeasyTemplateResponseMixin, ContextMixin, View):
+    """
+    Concrete view for serving PDF files.
+
+    .. code-block:: python
+
+        class HelloPDFView(WeasyTemplateView):
+            template_name = "hello.html"
+    """
+    def get(self, request, *args, **kwargs):
+        context = self.get_context_data(**kwargs)
+        return self.render_to_response(context)

oxutils/settings.py

@@ -21,6 +21,8 @@ class OxUtilsSettings(BaseSettings):
 
     # Service
     service_name: Optional[str] = 'Oxutils'
+    site_name: Optional[str] = 'Oxiliere'
+    site_domain: Optional[str] = 'oxiliere.com'
 
     # Auth JWT Settings (JWT_SIGNING_KEY)
     jwt_signing_key: Optional[str] = None

oxutils/users/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

oxutils/users/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class UsersConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'users'

oxutils/users/models.py

@@ -0,0 +1,88 @@
+from django.db import models
+
+from django.contrib.auth.models import AbstractUser, BaseUserManager
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+from safedelete.models import SafeDeleteModel
+from safedelete.models import SOFT_DELETE_CASCADE
+from auditlog.registry import auditlog
+from oxutils.models import BaseModelMixin
+
+
+
+class UserManager(BaseUserManager):
+    """
+    Gestionnaire personnalisé pour le modèle User
+    """
+    def create_user(self, email, oxi_id, **extra_fields):
+        """
+        Crée et sauvegarde un utilisateur avec l'email et l'oxi_id donnés.
+        """
+        if not email:
+            raise ValueError(_('The Email field must be set'))
+        if not oxi_id:
+            raise ValueError(_('The oxi_id field must be set'))
+        
+        email = self.normalize_email(email)
+        user = self.model(email=email, oxi_id=oxi_id, **extra_fields)
+        user.save(using=self._db)
+        return user
+
+    def create_superuser(self, email, oxi_id, **extra_fields):
+        """
+        Crée et sauvegarde un superutilisateur avec l'email et l'oxi_id donnés.
+        """
+        extra_fields.setdefault('is_staff', True)
+        extra_fields.setdefault('is_superuser', True)
+        extra_fields.setdefault('is_active', True)
+
+        if extra_fields.get('is_staff') is not True:
+            raise ValueError(_('Superuser must have is_staff=True.'))
+        if extra_fields.get('is_superuser') is not True:
+            raise ValueError(_('Superuser must have is_superuser=True.'))
+
+        return self.create_user(email, oxi_id, **extra_fields)
+
+
+class User(AbstractUser, SafeDeleteModel, BaseModelMixin):
+    """
+    Modèle d'utilisateur personnalisé qui utilise l'email comme identifiant unique
+    et intègre la suppression sécurisée (soft delete)
+    """
+    _safedelete_policy = SOFT_DELETE_CASCADE
+    
+    # Suppression du champ username qui est obligatoire dans AbstractUser
+    username = None
+    password = None # Don't need password
+
+    oxi_id = models.UUIDField(unique=True)  # id venant de auth.oxi.com
+    email = models.EmailField(unique=True)
+    is_active = models.BooleanField(default=True)
+    subscription_plan = models.CharField(max_length=255, null=True, blank=True)
+    subscription_status = models.CharField(max_length=255, null=True, blank=True)
+    subscription_end_date = models.DateTimeField(null=True, blank=True)
+
+    USERNAME_FIELD = "email"
+    REQUIRED_FIELDS = []
+
+    def __str__(self):
+        return self.email
+    
+    objects = UserManager()
+    
+    class Meta:
+        verbose_name = _('utilisateur')
+        verbose_name_plural = _('utilisateurs')
+        ordering = ['-created_at']
+        indexes = [
+            models.Index(fields=['oxi_id']),
+            models.Index(fields=['email']),
+        ]
+    
+    def __str__(self):
+        return self.email
+
+
+
+# Enregistrement du modèle User pour l'audit logging
+auditlog.register(User)

oxutils/users/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

oxutils/users/utils.py

@@ -0,0 +1,15 @@
+from django.contrib.auth import get_user_model
+
+
+def update_user(oxid: str, data: dict):
+    user = get_user_model().objects.get(oxi_id=oxid)
+    changes = False
+    if data:
+        for key, value in data.items():
+            if hasattr(user, key):
+                setattr(user, key, value)
+                changes = True
+    if changes:
+        user.save()
+
+    return user

{oxutils-0.1.2.dist-info → oxutils-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oxutils
-Version: 0.1.2
+Version: 0.1.5
 Summary: Production-ready utilities for Django applications in the Oxiliere ecosystem
 Keywords: django,utilities,jwt,s3,audit,logging,celery,structlog
 Author: Edimedia Mutoke
@@ -13,7 +13,6 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Internet :: WWW/HTTP
@@ -22,7 +21,6 @@ Requires-Dist: celery>=5.5.3
 Requires-Dist: cryptography>=46.0.3
 Requires-Dist: django-auditlog>=3.3.0
 Requires-Dist: django-celery-results>=2.6.0
-Requires-Dist: django-cid>=3.0
 Requires-Dist: django-extensions>=4.1
 Requires-Dist: django-ninja>=1.5.0
 Requires-Dist: django-ninja-extra>=0.30.6
@@ -32,7 +30,7 @@ Requires-Dist: jwcrypto>=1.5.6
 Requires-Dist: pydantic-settings>=2.12.0
 Requires-Dist: pyjwt>=2.10.1
 Requires-Dist: requests>=2.32.5
-Requires-Python: >=3.11
+Requires-Python: >=3.12
 Project-URL: Changelog, https://github.com/oxiliere/oxutils/blob/main/CHANGELOG.md
 Project-URL: Documentation, https://github.com/oxiliere/oxutils/tree/main/docs
 Project-URL: Homepage, https://github.com/oxiliere/oxutils
@@ -45,9 +43,9 @@ Description-Content-Type: text/markdown
 **Production-ready utilities for Django applications in the Oxiliere ecosystem.**
 
 [![PyPI version](https://img.shields.io/pypi/v/oxutils.svg)](https://pypi.org/project/oxutils/)
-[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/)
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/)
 [![Django 5.0+](https://img.shields.io/badge/django-5.0+-green.svg)](https://www.djangoproject.com/)
-[![Tests](https://img.shields.io/badge/tests-126%20passed-success.svg)](tests/)
+[![Tests](https://img.shields.io/badge/tests-201%20passed-success.svg)](tests/)
 [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
 [![Code style: ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://github.com/astral-sh/ruff)
 
@@ -55,11 +53,15 @@ Description-Content-Type: text/markdown
 
 - 🔐 **JWT Authentication** - RS256 with JWKS caching
 - 📦 **S3 Storage** - Static, media, private, and log backends
-- 📝 **Structured Logging** - JSON logs with correlation IDs
+- 📝 **Structured Logging** - JSON logs with automatic request tracking
 - 🔍 **Audit System** - Change tracking with S3 export
 - ⚙️ **Celery Integration** - Pre-configured task processing
 - 🛠️ **Django Mixins** - UUID, timestamps, user tracking
 - ⚡ **Custom Exceptions** - Standardized API errors
+- 🎨 **Context Processors** - Site name and domain for templates
+- 💱 **Currency Module** - Multi-source exchange rates (BCC/OXR)
+- 📄 **PDF Generation** - WeasyPrint integration for Django
+- 🏢 **Multi-Tenant** - PostgreSQL schema-based isolation
 
 ---
 
@@ -82,12 +84,12 @@ uv add oxutils
 from oxutils.conf import UTILS_APPS, AUDIT_MIDDLEWARE
 
 INSTALLED_APPS = [
-    *UTILS_APPS,  # structlog, auditlog, cid, celery_results
+    *UTILS_APPS,  # structlog, auditlog, celery_results
     # your apps...
 ]
 
 MIDDLEWARE = [
-    *AUDIT_MIDDLEWARE,  # CID, Auditlog, RequestMiddleware
+    *AUDIT_MIDDLEWARE,  # RequestMiddleware, Auditlog
     # your middleware...
 ]
 ```
@@ -126,10 +128,22 @@ class Product(BaseModelMixin):  # UUID + timestamps + is_active
 # Custom Exceptions
 from oxutils.exceptions import NotFoundException
 raise NotFoundException(detail="User not found")
+
+# Context Processors
+# settings.py
+TEMPLATES = [{
+    'OPTIONS': {
+        'context_processors': [
+            'oxutils.context.site_name_processor.site_name',
+        ],
+    },
+}]
+# Now {{ site_name }} and {{ site_domain }} are available in templates
 ```
 
 ## Documentation
 
+### Core Modules
 - **[Settings](docs/settings.md)** - Configuration reference
 - **[JWT](docs/jwt.md)** - Authentication
 - **[S3](docs/s3.md)** - Storage backends
@@ -138,9 +152,14 @@ raise NotFoundException(detail="User not found")
 - **[Mixins](docs/mixins.md)** - Model/service mixins
 - **[Celery](docs/celery.md)** - Task processing
 
+### Additional Modules
+- **[Currency](docs/currency.md)** - Exchange rates management
+- **[PDF](docs/pdf.md)** - PDF generation with WeasyPrint
+- **[Oxiliere](docs/oxiliere.md)** - Multi-tenant architecture
+
 ## Requirements
 
-- Python 3.11+
+- Python 3.12+
 - Django 5.0+
 - PostgreSQL (recommended)
 
@@ -150,7 +169,7 @@ raise NotFoundException(detail="User not found")
 git clone https://github.com/oxiliere/oxutils.git
 cd oxutils
 uv sync
-uv run pytest  # 126 tests
+uv run pytest  # 201 tests passing, 4 skipped
 ```
 
 ### Creating Migrations
@@ -165,6 +184,19 @@ uv run make_migrations.py
 
 See [MIGRATIONS.md](MIGRATIONS.md) for detailed documentation.
 
+## Optional Dependencies
+
+```bash
+# Multi-tenant support
+uv add oxutils[oxiliere]
+
+# PDF generation
+uv add oxutils[pdf]
+
+# Development tools
+uv add oxutils[dev]
+```
+
 ## Advanced Examples
 
 ### JWT with Django Ninja
@@ -199,6 +231,55 @@ export = export_logs_from_date(from_date=from_date)
 print(f"Exported to {export.data.url}")
 ```
 
+### Currency Exchange Rates
+
+```python
+from oxutils.currency.models import CurrencyState
+
+# Sync rates from BCC (with OXR fallback)
+state = CurrencyState.sync()
+
+# Get latest rates
+latest = CurrencyState.objects.latest()
+usd_rate = latest.currencies.get(code='USD').rate
+eur_rate = latest.currencies.get(code='EUR').rate
+```
+
+### PDF Generation
+
+```python
+from oxutils.pdf.printer import Printer
+from oxutils.pdf.views import WeasyTemplateView
+
+# Standalone PDF generation
+printer = Printer(
+    template_name='invoice.html',
+    context={'invoice': invoice},
+    stylesheets=['css/invoice.css']
+)
+pdf_bytes = printer.write_pdf()
+
+# Class-based view
+class InvoicePDFView(WeasyTemplateView):
+    template_name = 'invoice.html'
+    pdf_filename = 'invoice.pdf'
+    pdf_stylesheets = ['css/invoice.css']
+```
+
+### Multi-Tenant Setup
+
+```python
+# settings.py
+TENANT_MODEL = "oxiliere.Tenant"
+MIDDLEWARE = [
+    'oxutils.oxiliere.middleware.TenantMainMiddleware',  # First!
+    # other middleware...
+]
+
+# All requests must include X-Organization-ID header
+# Data is automatically isolated per tenant schema
+```
+
 ## License
 
 Apache 2.0 License - see [LICENSE](LICENSE)