oxutils 0.1.11__tar.gz → 0.1.14__tar.gz

{oxutils-0.1.11 → oxutils-0.1.14}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: oxutils
-Version: 0.1.11
+Version: 0.1.14
 Summary: Production-ready utilities for Django applications in the Oxiliere ecosystem
-Keywords: django,utilities,jwt,s3,audit,logging,celery,structlog
+Keywords: django,utilities,jwt,audit,logging,celery,structlog
 Author: Edimedia Mutoke
 Author-email: Edimedia Mutoke <eddycondor07@gmail.com>
 License-Expression: Apache-2.0
@@ -24,7 +24,6 @@ Requires-Dist: django-celery-results>=2.6.0
 Requires-Dist: django-extensions>=4.1
 Requires-Dist: django-ninja>=1.5.0
 Requires-Dist: django-ninja-extra>=0.30.6
-Requires-Dist: django-storages[s3]>=1.14.6
 Requires-Dist: django-structlog[celery]>=10.0.0
 Requires-Dist: jwcrypto>=1.5.6
 Requires-Dist: pydantic-settings>=2.12.0
@@ -71,7 +70,6 @@ Description-Content-Type: text/markdown
 ## Features
 
 - 🔐 **JWT Authentication** - RS256 with JWKS caching
-- 📦 **S3 Storage** - Static, media, private, and log backends
 - 📝 **Structured Logging** - JSON logs with automatic request tracking
 - 🔍 **Audit System** - Change tracking with S3 export
 - ⚙️ **Celery Integration** - Pre-configured task processing
@@ -118,8 +116,6 @@ MIDDLEWARE = [
 ```bash
 OXI_SERVICE_NAME=my-service
 OXI_JWT_JWKS_URL=https://auth.example.com/.well-known/jwks.json
-OXI_USE_STATIC_S3=True
-OXI_STATIC_STORAGE_BUCKET_NAME=my-bucket
 ```
 
 ### 3. Usage Examples
@@ -134,10 +130,6 @@ import structlog
 logger = structlog.get_logger(__name__)
 logger.info("user_action", user_id=user_id)
 
-# S3 Storage
-from oxutils.s3.storages import PrivateMediaStorage
-class Document(models.Model):
-    file = models.FileField(storage=PrivateMediaStorage())
 
 # Model Mixins
 from oxutils.models.base import BaseModelMixin
@@ -165,7 +157,6 @@ TEMPLATES = [{
 ### Core Modules
 - **[Settings](docs/settings.md)** - Configuration reference
 - **[JWT](docs/jwt.md)** - Authentication
-- **[S3](docs/s3.md)** - Storage backends
 - **[Audit](docs/audit.md)** - Change tracking
 - **[Logging](docs/logger.md)** - Structured logs
 - **[Mixins](docs/mixins.md)** - Model/service mixins

{oxutils-0.1.11 → oxutils-0.1.14}/README.md

@@ -12,7 +12,6 @@
 ## Features
 
 - 🔐 **JWT Authentication** - RS256 with JWKS caching
-- 📦 **S3 Storage** - Static, media, private, and log backends
 - 📝 **Structured Logging** - JSON logs with automatic request tracking
 - 🔍 **Audit System** - Change tracking with S3 export
 - ⚙️ **Celery Integration** - Pre-configured task processing
@@ -59,8 +58,6 @@ MIDDLEWARE = [
 ```bash
 OXI_SERVICE_NAME=my-service
 OXI_JWT_JWKS_URL=https://auth.example.com/.well-known/jwks.json
-OXI_USE_STATIC_S3=True
-OXI_STATIC_STORAGE_BUCKET_NAME=my-bucket
 ```
 
 ### 3. Usage Examples
@@ -75,10 +72,6 @@ import structlog
 logger = structlog.get_logger(__name__)
 logger.info("user_action", user_id=user_id)
 
-# S3 Storage
-from oxutils.s3.storages import PrivateMediaStorage
-class Document(models.Model):
-    file = models.FileField(storage=PrivateMediaStorage())
 
 # Model Mixins
 from oxutils.models.base import BaseModelMixin
@@ -106,7 +99,6 @@ TEMPLATES = [{
 ### Core Modules
 - **[Settings](docs/settings.md)** - Configuration reference
 - **[JWT](docs/jwt.md)** - Authentication
-- **[S3](docs/s3.md)** - Storage backends
 - **[Audit](docs/audit.md)** - Change tracking
 - **[Logging](docs/logger.md)** - Structured logs
 - **[Mixins](docs/mixins.md)** - Model/service mixins

{oxutils-0.1.11 → oxutils-0.1.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "oxutils"
-version = "0.1.11"
+version = "0.1.14"
 description = "Production-ready utilities for Django applications in the Oxiliere ecosystem"
 readme = "README.md"
 license = "Apache-2.0"
@@ -8,7 +8,7 @@ authors = [
     { name = "Edimedia Mutoke", email = "eddycondor07@gmail.com" }
 ]
 requires-python = ">=3.12"
-keywords = ["django", "utilities", "jwt", "s3", "audit", "logging", "celery", "structlog"]
+keywords = ["django", "utilities", "jwt", "audit", "logging", "celery", "structlog"]
 classifiers = [
     "Development Status :: 4 - Beta",
     "Framework :: Django",
@@ -30,7 +30,6 @@ dependencies = [
     "django-extensions>=4.1",
     "django-ninja>=1.5.0",
     "django-ninja-extra>=0.30.6",
-    "django-storages[s3]>=1.14.6",
     "django-structlog[celery]>=10.0.0",
     "jwcrypto>=1.5.6",
     "pydantic-settings>=2.12.0",

{oxutils-0.1.11 → oxutils-0.1.14}/src/oxutils/__init__.py

@@ -2,7 +2,6 @@
 
 This package provides:
 - JWT authentication with JWKS support
-- S3 storage backends (static, media, private, logs)
 - Structured logging with correlation IDs
 - Audit system with S3 export
 - Celery integration
@@ -11,7 +10,7 @@ This package provides:
 - Permission management
 """
 
-__version__ = "0.1.10"
+__version__ = "0.1.14"
 
 from oxutils.settings import oxi_settings
 from oxutils.conf import UTILS_APPS, AUDIT_MIDDLEWARE

{oxutils-0.1.11 → oxutils-0.1.14}/src/oxutils/audit/migrations/0001_initial.py

@@ -2,7 +2,7 @@
 
 import django.db.models.deletion
 import oxutils.enums.audit
-import oxutils.s3.storages
+from oxutils.logger import get_log_storage
 from django.db import migrations, models
 
 
@@ -22,7 +22,7 @@ class Migration(migrations.Migration):
                 ('updated_at', models.DateTimeField(auto_now=True, help_text='Date and time when this record was last updated')),
                 ('last_export_date', models.DateTimeField(null=True)),
                 ('status', models.CharField(choices=[(oxutils.enums.audit.ExportStatus['FAILED'], 'Failed'), (oxutils.enums.audit.ExportStatus['PENDING'], 'Pending'), (oxutils.enums.audit.ExportStatus['SUCCESS'], 'Success')], default=oxutils.enums.audit.ExportStatus['PENDING'])),
-                ('data', models.FileField(storage=oxutils.s3.storages.LogStorage(), upload_to='')),
+                ('data', models.FileField(storage=get_log_storage, upload_to='')),
                 ('size', models.BigIntegerField()),
             ],
             options={

{oxutils-0.1.11 → oxutils-0.1.14}/src/oxutils/audit/models.py

@@ -3,7 +3,7 @@ from django.utils import timezone
 from django.db import models, transaction
 from oxutils.enums.audit import ExportStatus
 from oxutils.models.base import TimestampMixin
-from oxutils.s3.storages import LogStorage
+from oxutils.logger import get_log_storage
 
 
 
@@ -38,7 +38,7 @@ class LogExportState(TimestampMixin):
             (ExportStatus.SUCCESS, _('Success'))
         )
     )
-    data = models.FileField(storage=LogStorage())
+    data = models.FileField(storage=get_log_storage)
     size = models.BigIntegerField()
 
     @classmethod

oxutils-0.1.14/src/oxutils/logger/__init__.py

@@ -0,0 +1,10 @@
+from django.core.files.storage import storages, default_storage
+
+
+def get_log_storage():
+    try:
+        return storages['logs']
+    except:
+        pass
+
+    return default_storage

{oxutils-0.1.11 → oxutils-0.1.14}/src/oxutils/oxiliere/caches.py

@@ -1,4 +1,3 @@
-from django.conf import settings
 from cacheops import cached_as, cached
 from oxutils.oxiliere.utils import (
     get_tenant_model,

oxutils-0.1.14/src/oxutils/permissions/caches.py

@@ -0,0 +1,33 @@
+from django.conf import settings
+
+
+
+CACHE_CHECK_PERMISSION = getattr(settings, 'CACHE_CHECK_PERMISSION', False)
+
+if CACHE_CHECK_PERMISSION:
+    from cacheops import cached_as
+    from .models import Grant
+    from .utils import check, any_action_check, any_permission_check
+
+    @cached_as(Grant, timeout=60*15)
+    def cache_check(user, scope, actions, group = None, **context):
+        return check(user, scope, actions, group, **context)
+    
+    @cached_as(Grant, timeout=60*15)
+    def cache_any_action_check(user, scope, required, group = None, **context):
+        return any_action_check(user, scope, required, group, **context)
+    
+    @cached_as(Grant, timeout=60*15)
+    def cache_any_permission_check(user, *str_perms):
+        return any_permission_check(user, *str_perms)
+else:
+    from .utils import check, any_action_check, any_permission_check
+
+    def cache_check(user, scope, actions, group = None, **context):
+        return check(user, scope, actions, group, **context)
+    
+    def cache_any_action_check(user, scope, required, group = None, **context):
+        return any_action_check(user, scope, required, group, **context)
+    
+    def cache_any_permission_check(user, *str_perms):
+        return any_permission_check(user, *str_perms)

oxutils-0.1.14/src/oxutils/permissions/perms.py

@@ -0,0 +1,201 @@
+from typing import Optional
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+from django.http import HttpRequest
+from ninja_extra.permissions import BasePermission
+from ninja_extra.controllers import ControllerBase
+
+from oxutils.permissions.utils import str_check
+
+
+
+class ScopePermission(BasePermission):
+    """
+    Permission class for checking user permissions using the string format.
+    
+    Format: "<scope>:<actions>:<group>?key=value"
+    
+    Example:
+        @api_controller('/articles', permissions=[ScopePermission('articles:w:staff')])
+        class ArticleController:
+            pass
+    """
+
+    def __init__(self, perm: str, ctx: Optional[dict] = None):
+        """
+        Initialize the permission checker.
+        
+        Args:
+            perm: Permission string in format "<scope>:<actions>:<group>?context"
+        """
+        self.perm = perm
+        self.ctx = ctx if ctx else dict()
+
+    def has_permission(self, request: HttpRequest, controller: ControllerBase) -> bool:
+        """
+        Check if the user has the required permission.
+        
+        Args:
+            request: HTTP request object
+            controller: Controller instance
+            
+        Returns:
+            True if user has permission, False otherwise
+        """
+        return str_check(request.user, self.perm, **self.ctx)
+
+
+class ScopeAnyPermission(BasePermission):
+    """
+    Permission class for checking if user has at least one of multiple permissions.
+    
+    Vérifie si l'utilisateur possède au moins une des permissions fournies.
+    Utilise any_permission_check pour une vérification optimisée en une seule requête.
+    
+    Example:
+        @api_controller('/articles', permissions=[
+            ScopeAnyPermission('articles:r', 'articles:w:staff', 'articles:d:admin')
+        ])
+        class ArticleController:
+            # User needs either read access, OR staff write access, OR admin delete access
+            pass
+    """
+
+    def __init__(self, *perms: str):
+        """
+        Initialize the permission checker with multiple permission strings.
+        
+        Args:
+            *perms: Variable number of permission strings in format "<scope>:<actions>:<group>?context"
+        """
+        if not perms:
+            raise ValueError("At least one permission string must be provided")
+        self.perms = perms
+
+    def has_permission(self, request: HttpRequest, controller: ControllerBase) -> bool:
+        """
+        Check if the user has at least one of the required permissions.
+        
+        Args:
+            request: HTTP request object
+            controller: Controller instance
+            
+        Returns:
+            True if user has at least one permission, False otherwise
+        """
+        from oxutils.permissions.caches import cache_any_permission_check
+        return cache_any_permission_check(request.user, *self.perms)
+
+
+class ScopeAnyActionPermission(BasePermission):
+    """
+    Permission class for checking if user has at least one of multiple actions on a scope.
+    
+    Vérifie si l'utilisateur possède au moins une des actions requises pour un scope donné.
+    La chaîne d'actions contient plusieurs actions dont au moins une est requise.
+    
+    Example:
+        @api_controller('/articles', permissions=[
+            ScopeAnyActionPermission('articles:rwd:staff')
+        ])
+        class ArticleController:
+            # User needs read OR write OR delete access on articles in staff group
+            pass
+            
+        @api_controller('/invoices', permissions=[
+            ScopeAnyActionPermission('invoices:rw?tenant_id=123')
+        ])
+        class InvoiceController:
+            # User needs read OR write access on invoices with tenant_id=123
+            pass
+    """
+
+    def __init__(self, perm: str, ctx: Optional[dict] = None):
+        """
+        Initialize the permission checker with a permission string.
+        
+        Args:
+            perm: Permission string in format "<scope>:<actions>:<group>?context"
+                  where actions contains multiple characters (e.g., 'rwd' for read OR write OR delete)
+            ctx: Optional additional context dict
+        """
+        if not perm:
+            raise ValueError("Permission string must be provided")
+        
+        self.perm = perm
+        self.ctx = ctx if ctx else dict()
+
+    def has_permission(self, request: HttpRequest, controller: ControllerBase) -> bool:
+        """
+        Check if the user has at least one of the required actions.
+        
+        Args:
+            request: HTTP request object
+            controller: Controller instance
+            
+        Returns:
+            True if user has at least one action, False otherwise
+        """
+        from oxutils.permissions.caches import cache_any_action_check
+        from oxutils.permissions.utils import parse_permission
+        
+        scope, actions, group, query_context = parse_permission(self.perm)
+        final_context = {**query_context, **self.ctx}
+        
+        return cache_any_action_check(
+            request.user,
+            scope,
+            actions,
+            group,
+            **final_context
+        )
+
+
+def access_manager(actions: str):
+    """
+    Factory function for creating ScopePermission instances for access manager.
+    
+    Builds a permission string from settings:
+    - ACCESS_MANAGER_SCOPE: The scope to check
+    - ACCESS_MANAGER_GROUP: Optional group filter
+    - ACCESS_MANAGER_CONTEXT: Optional context dict converted to query params
+    
+    Args:
+        actions: Actions required (e.g., 'r', 'rw', 'rwd')
+        
+    Returns:
+        ScopePermission instance configured with access manager settings
+        
+    Raises:
+        ImproperlyConfigured: If required settings are missing
+        
+    Example:
+        @api_controller('/access', permissions=[access_manager('w')])
+        class AccessController:
+            pass
+    """
+    # Validate required settings
+    if not hasattr(settings, 'ACCESS_MANAGER_SCOPE'):
+        raise ImproperlyConfigured(
+            'ACCESS_MANAGER_SCOPE is not defined. '
+            'Add ACCESS_MANAGER_SCOPE = "access" to your settings.'
+        )
+    
+    # Build base permission string: scope:actions
+    perm = f"{settings.ACCESS_MANAGER_SCOPE}:{actions}"
+    
+    # Add group if defined and not None
+    if hasattr(settings, 'ACCESS_MANAGER_GROUP') and settings.ACCESS_MANAGER_GROUP is not None:
+        perm += f":{settings.ACCESS_MANAGER_GROUP}"
+    
+    # Get context if defined and not empty
+    context = {}
+    if hasattr(settings, 'ACCESS_MANAGER_CONTEXT') and settings.ACCESS_MANAGER_CONTEXT:
+        context = settings.ACCESS_MANAGER_CONTEXT
+        if not isinstance(context, dict):
+            raise ImproperlyConfigured(
+                'ACCESS_MANAGER_CONTEXT must be a dictionary. '
+                f'Got {type(context).__name__} instead.'
+            )
+    
+    return ScopePermission(perm, context)

{oxutils-0.1.11 → oxutils-0.1.14}/src/oxutils/permissions/utils.py

@@ -387,41 +387,156 @@ def check(
     # Vérifier l'existence d'un grant correspondant
     return Grant.objects.filter(grant_filter).exists()
 
-def str_check(user: AbstractBaseUser, perm: str, **context: Any) -> bool:
+
+def any_action_check(
+    user: AbstractBaseUser,
+    scope: str,
+    required: list[str],
+    group: Optional[str] = None,
+    **context: Any
+) -> bool:
     """
-    Vérifie si un utilisateur possède les permissions requises à partir d'une chaîne formatée.
+    Vérifie si un utilisateur possède au moins une des actions requises pour un scope donné.
+    
+    Cette fonction utilise une seule requête optimisée avec des conditions OR pour vérifier
+    si l'utilisateur possède au moins une des actions dans la liste.
     
     Args:
         user: L'utilisateur dont on vérifie les permissions
-        perm: Chaîne de permission au format "<scope>:<actions>:<group>?key=value&key2=value2"
-              - scope: Le scope à vérifier (ex: 'articles')
-              - actions: Actions requises (ex: 'rw', 'r', 'rwdx')
-              - group: (Optionnel) Slug du groupe
-              - query params: (Optionnel) Contexte sous forme de query parameters
-        **context: Contexte additionnel pour filtrer les grants (fusionné avec les query params)
+        scope: Le scope à vérifier (ex: 'articles', 'invoices')
+        required: Liste des actions dont au moins une est requise (ex: ['r', 'w'], ['d'])
+        group: Slug du groupe optionnel pour filtrer les grants par groupe
+        **context: Contexte additionnel pour filtrer les grants (clés JSON)
         
     Returns:
-        True si l'utilisateur possède les permissions requises, False sinon
+        True si l'utilisateur possède au moins une des actions requises, False sinon
         
     Example:
-        >>> # Vérifier lecture sur articles
-        >>> str_check(user, 'articles:r')
-        True
-        >>> # Vérifier écriture sur articles dans le groupe staff
-        >>> str_check(user, 'articles:w:staff')
+        >>> # Vérifier si l'utilisateur peut lire OU écrire les articles
+        >>> any_action_check(user, 'articles', ['r', 'w'])
         True
-        >>> # Avec contexte via query params
-        >>> str_check(user, 'articles:w?tenant_id=123&status=published')
+        >>> # Vérifier avec contexte
+        >>> any_action_check(user, 'articles', ['w', 'd'], tenant_id=123)
         False
-        >>> # Avec groupe et contexte
-        >>> str_check(user, 'articles:w:staff?tenant_id=123')
+        >>> # Vérifier dans le contexte d'un groupe spécifique
+        >>> any_action_check(user, 'articles', ['r', 'w'], group='staff')
         True
-        >>> # Contexte mixte (query params + kwargs)
-        >>> str_check(user, 'articles:w?tenant_id=123', level=2)
+        
+    Note:
+        Les actions sont automatiquement expandées lors de la création du grant,
+        donc si un grant contient ['w'], il contient aussi ['r'] implicitement.
+        Cette fonction vérifie si AU MOINS UNE des actions requises est présente.
+    """
+    # Construire le filtre de base pour l'utilisateur et le scope
+    grant_filter = Q(user__pk=user.pk, scope=scope)
+    
+    # Filtrer par groupe si spécifié
+    if group:
+        grant_filter &= Q(user_group__group__slug=group)
+    
+    # Ajouter les filtres de contexte si fournis
+    if context:
+        grant_filter &= Q(context__contains=context)
+    
+    # Vérifier si au moins une des actions requises est présente dans le grant
+    # Utilise l'opérateur overlap (&&) pour une requête optimale
+    grant_filter &= Q(actions__overlap=required)
+    
+    # Vérifier l'existence d'un grant correspondant
+    return Grant.objects.filter(grant_filter).exists()
+
+
+def any_permission_check(user: AbstractBaseUser, *str_perms: str) -> bool:
+    """
+    Vérifie si un utilisateur possède au moins une des permissions fournies.
+    
+    Cette fonction parse toutes les permissions fournies et effectue une seule requête
+    optimisée avec des conditions OR pour vérifier si l'utilisateur possède au moins
+    une des permissions.
+    
+    Args:
+        user: L'utilisateur dont on vérifie les permissions
+        *str_perms: Liste de chaînes de permissions au format standard
+                    (ex: 'articles:r', 'invoices:w:staff', 'users:d?tenant_id=123')
+        
+    Returns:
+        True si l'utilisateur possède au moins une des permissions, False sinon
+        
+    Example:
+        >>> # Vérifier si l'utilisateur peut lire les articles OU écrire les factures
+        >>> any_permission_check(user, 'articles:r', 'invoices:w')
+        True
+        >>> # Avec différents groupes et contextes
+        >>> any_permission_check(
+        ...     user,
+        ...     'articles:w:staff',
+        ...     'invoices:r:admin',
+        ...     'users:d?tenant_id=123'
+        ... )
         False
+        
+    Note:
+        Toute la vérification se fait au niveau de la base de données avec une seule
+        requête utilisant des conditions OR pour optimiser les performances.
     """
-    from .caches import cache_check
+    if not str_perms:
+        return False
+    
+    # Construire le filtre de base pour l'utilisateur
+    base_filter = Q(user__pk=user.pk)
+    
+    # Construire les conditions OR pour chaque permission
+    permission_filters = Q()
+    
+    for perm in str_perms:
+        # Parser la permission
+        scope, actions, group, context = parse_permission(perm)
+        
+        # Construire le filtre pour cette permission spécifique
+        perm_filter = Q(scope=scope, actions__overlap=actions)
+        
+        # Ajouter le filtre de groupe si spécifié
+        if group:
+            perm_filter &= Q(user_group__group__slug=group)
+        
+        # Ajouter le filtre de contexte si fourni
+        if context:
+            perm_filter &= Q(context__contains=context)
+        
+        # Ajouter cette permission aux conditions OR
+        permission_filters |= perm_filter
+    
+    # Combiner le filtre de base avec les conditions OR et vérifier l'existence
+    return Grant.objects.filter(base_filter & permission_filters).exists()
+
 
+def parse_permission(perm: str) -> tuple[str, list[str], Optional[str], dict[str, Any]]:
+    """
+    Parse une chaîne de permission et retourne ses composants.
+    
+    Args:
+        perm: Chaîne de permission au format "<scope>:<actions>:<group>?key=value&key2=value2"
+              - scope: Le scope (ex: 'articles')
+              - actions: Actions requises (ex: 'rw', 'r', 'rwdx')
+              - group: (Optionnel) Slug du groupe
+              - query params: (Optionnel) Contexte sous forme de query parameters
+              
+    Returns:
+        Tuple contenant (scope, actions_list, group, context_dict)
+        
+    Raises:
+        ValueError: Si le format de la permission est invalide
+        
+    Example:
+        >>> parse_permission('articles:rw')
+        ('articles', ['r', 'w'], None, {})
+        >>> parse_permission('articles:w:staff')
+        ('articles', ['w'], 'staff', {})
+        >>> parse_permission('articles:rw?tenant_id=123&status=published')
+        ('articles', ['r', 'w'], None, {'tenant_id': 123, 'status': 'published'})
+        >>> parse_permission('articles:w:staff?tenant_id=123')
+        ('articles', ['w'], 'staff', {'tenant_id': 123})
+    """
     # Séparer la partie principale des query params
     if '?' in perm:
         from urllib.parse import parse_qs
@@ -455,7 +570,48 @@ def str_check(user: AbstractBaseUser, perm: str, **context: Any) -> bool:
     
     # Convertir la chaîne d'actions en liste
     # 'rwd' -> ['r', 'w', 'd']
-    required = list(actions_str)
+    actions_list = list(actions_str)
+    
+    return scope, actions_list, group, query_context
+
+
+def str_check(user: AbstractBaseUser, perm: str, **context: Any) -> bool:
+    """
+    Vérifie si un utilisateur possède les permissions requises à partir d'une chaîne formatée.
+    
+    Args:
+        user: L'utilisateur dont on vérifie les permissions
+        perm: Chaîne de permission au format "<scope>:<actions>:<group>?key=value&key2=value2"
+              - scope: Le scope à vérifier (ex: 'articles')
+              - actions: Actions requises (ex: 'rw', 'r', 'rwdx')
+              - group: (Optionnel) Slug du groupe
+              - query params: (Optionnel) Contexte sous forme de query parameters
+        **context: Contexte additionnel pour filtrer les grants (fusionné avec les query params)
+        
+    Returns:
+        True si l'utilisateur possède les permissions requises, False sinon
+        
+    Example:
+        >>> # Vérifier lecture sur articles
+        >>> str_check(user, 'articles:r')
+        True
+        >>> # Vérifier écriture sur articles dans le groupe staff
+        >>> str_check(user, 'articles:w:staff')
+        True
+        >>> # Avec contexte via query params
+        >>> str_check(user, 'articles:w?tenant_id=123&status=published')
+        False
+        >>> # Avec groupe et contexte
+        >>> str_check(user, 'articles:w:staff?tenant_id=123')
+        True
+        >>> # Contexte mixte (query params + kwargs)
+        >>> str_check(user, 'articles:w?tenant_id=123', level=2)
+        False
+    """
+    from .caches import cache_check
+
+    # Parser la chaîne de permission
+    scope, required, group, query_context = parse_permission(perm)
     
     # Fusionner les contextes (kwargs ont priorité sur query params)
     final_context = {**query_context, **context}