django-nativemojo 0.1.10__py3-none-any.whl → 0.1.16__py3-none-any.whl

mojo/models/secrets.py

@@ -11,12 +11,18 @@ class MojoSecrets(models.Model):
 
     mojo_secrets = models.TextField(blank=True, null=True, default=None)
     _exposed_secrets = None
+    _secrets_changed = False
 
     def set_secrets(self, value):
+        self.debug("Setting secrets", repr(value))
+        if isinstance(value, str):
+            value = objict.from_json(value)
         self._exposed_secrets = merge_dicts(self.secrets, value)
+        self._secrets_changed = True
 
     def set_secret(self, key, value):
         self.secrets[key] = value
+        self._secrets_changed = True
 
     def get_secret(self, key, default=None):
         return self.secrets.get(key, default)
@@ -24,6 +30,7 @@ class MojoSecrets(models.Model):
     def clear_secrets(self):
         self.mojo_secrets = None
         self._exposed_secrets = objict()
+        self._secrets_changed = True
 
     @property
     def secrets(self):
@@ -44,10 +51,79 @@ class MojoSecrets(models.Model):
         return salt
 
     def save_secrets(self):
-        if self._exposed_secrets:
-            self.mojo_secrets = crypto.encrypt( self._exposed_secrets, self._get_secrets_password())
+        if self._secrets_changed:
+            if self._exposed_secrets:
+                self.mojo_secrets = crypto.encrypt( self._exposed_secrets, self._get_secrets_password())
+            else:
+                self.mojo_secrets = None
+            self._secrets_changed = False
+
+    def save(self, *args, **kwargs):
+        if self.pk is not None:
+            self.save_secrets()
+            super().save(*args, **kwargs)
         else:
-            self.mojo_secrets = None
+            super().save(*args, **kwargs)
+            self.save_secrets()
+            super().save()
+
+
+
+class KSMSecrets(models.Model):
+    """Base model class for adding secrets to a model using AWS KMS (envelope encryption)."""
+    class Meta:
+        abstract = True
+
+    mojo_secrets = models.TextField(blank=True, null=True, default=None)
+    _exposed_secrets = None
+    _secrets_changed = False
+    _kms_cache = {}
+
+    def set_secrets(self, value):
+        self.debug("Setting secrets", repr(value))
+        if isinstance(value, str):
+            value = objict.from_json(value)
+        self._exposed_secrets = merge_dicts(self.secrets, value)
+        self._secrets_changed = True
+
+    def set_secret(self, key, value):
+        self.secrets[key] = value
+        self._secrets_changed = True
+
+    def get_secret(self, key, default=None):
+        return self.secrets.get(key, default)
+
+    def clear_secrets(self):
+        self.mojo_secrets = None
+        self._exposed_secrets = objict()
+        self._secrets_changed = True
+
+    @property
+    def secrets(self):
+        if self._exposed_secrets is not None:
+            return self._exposed_secrets
+        if self.mojo_secrets is None or self.pk is None:
+            self._exposed_secrets = objict()
+            return self._exposed_secrets
+        if self._exposed_secrets is None:
+            try:
+                data = self._get_kms().decrypt_dict_field(self._kms_context(), self.mojo_secrets)
+                # convert to objict mapping
+                self._exposed_secrets = objict.from_dict(data)
+            except Exception:
+                # On failure, expose empty to avoid leaking details
+                self._exposed_secrets = objict()
+        return self._exposed_secrets
+
+    def save_secrets(self):
+        if self._secrets_changed:
+            if self._exposed_secrets:
+                # objict behaves like a dict; KMSHelper accepts dict
+                blob = self._get_kms().encrypt_field(self._kms_context(), self._exposed_secrets)
+                self.mojo_secrets = blob
+            else:
+                self.mojo_secrets = None
+            self._secrets_changed = False
 
     def save(self, *args, **kwargs):
         if self.pk is not None:
@@ -57,3 +133,22 @@ class MojoSecrets(models.Model):
             super().save(*args, **kwargs)
             self.save_secrets()
             super().save()
+
+    @classmethod
+    def _get_kms(cls):
+        kms_key_id = settings.get("KMS_KEY_ID", None)
+        region = settings.get("AWS_REGION", settings.get("AWS_DEFAULT_REGION", "us-east-1"))
+        if not kms_key_id:
+            raise RuntimeError("KMS_KEY_ID must be configured to use KSMSecrets")
+        cache_key = (kms_key_id, region)
+        helper = cls._kms_cache.get(cache_key)
+        if helper is None:
+            from mojo.helpers.aws.kms import KMSHelper
+            helper = KMSHelper(kms_key_id=kms_key_id, region_name=region)
+            cls._kms_cache[cache_key] = helper
+        return helper
+
+    def _kms_context(self):
+        # Bind to app_label.Model.<pk>.mojo_secrets for contextual integrity
+        app_label = getattr(self._meta, "app_label", self.__class__.__module__.split(".")[0])
+        return f"{app_label}.{self.__class__.__name__}.{self.pk}.mojo_secrets"

mojo/serializers/__init__.py

@@ -0,0 +1,106 @@
+"""
+Django-MOJO Serializers Package
+
+Provides high-performance serialization for Django models with RestMeta.GRAPHS support.
+Includes multiple serializer backends optimized for different use cases:
+
+- OptimizedGraphSerializer: Ultra-fast with intelligent caching (default)
+- GraphSerializer: Simple and reliable fallback
+- AdvancedGraphSerializer: Feature-rich with multiple format support
+
+Usage:
+    from mojo.serializers import serialize, to_json, to_response
+
+    # Quick serialization
+    data = serialize(instance, graph="detail")
+    json_str = to_json(queryset, graph="list")
+    response = to_response(instance, request, graph="default")
+
+    # Direct serializer access
+    from mojo.serializers import OptimizedGraphSerializer
+    serializer = OptimizedGraphSerializer(instance, graph="detail")
+    data = serializer.serialize()
+"""
+
+# Core serializer classes
+from .simple import GraphSerializer
+
+# New optimized core system (default)
+from .core import (
+    OptimizedGraphSerializer,
+    SerializerManager,
+    get_serializer_manager,
+    register_serializer,
+    set_default_serializer,
+    serialize,
+    to_json,
+    to_response,
+    get_performance_stats,
+    clear_serializer_caches,
+    benchmark_serializers,
+    HAS_UJSON,
+    UJSON_VERSION
+)
+
+# Advanced serializer (optional - may not be available)
+try:
+    from .advanced import AdvancedGraphSerializer
+except ImportError:
+    AdvancedGraphSerializer = None
+
+# Version and metadata
+__version__ = "2.0.0"
+__author__ = "Django-MOJO Team"
+
+# Default exports
+__all__ = [
+    # Core serializer classes
+    'GraphSerializer',
+    'OptimizedGraphSerializer',
+    'AdvancedGraphSerializer',
+
+    # Manager
+    'SerializerManager',
+    'get_serializer_manager',
+
+    # Registration functions
+    'register_serializer',
+    'set_default_serializer',
+
+    # Convenience functions
+    'serialize',
+    'to_json',
+    'to_response',
+
+    # Performance monitoring
+    'get_performance_stats',
+    'clear_serializer_caches',
+    'benchmark_serializers',
+
+    # Performance info
+    'HAS_UJSON',
+    'UJSON_VERSION',
+]
+
+# Initialize default manager on import
+_manager = get_serializer_manager()
+
+# Convenience shortcuts at package level
+def get_serializer(instance, graph="default", many=None, serializer_type=None, **kwargs):
+    """Get configured serializer instance."""
+    return _manager.get_serializer(instance, graph, many, serializer_type, **kwargs)
+
+def list_serializers():
+    """List all registered serializers."""
+    return _manager.registry.list_serializers()
+
+def get_default_serializer():
+    """Get the current default serializer name."""
+    return _manager.registry.get_default()
+
+# Add shortcuts to exports
+__all__.extend([
+    'get_serializer',
+    'list_serializers',
+    'get_default_serializer'
+])

mojo/serializers/core/__init__.py

@@ -0,0 +1,90 @@
+"""
+Django-MOJO Core Serializers
+
+High-performance serialization system with intelligent caching and RestMeta.GRAPHS support.
+This is the optimized serializer implementation with pluggable cache backends.
+
+Main Components:
+- OptimizedGraphSerializer: Ultra-fast serializer with smart caching
+- SerializerManager: Unified interface for all serializer backends
+- Cache backends: Memory and Redis-based caching systems
+
+Usage:
+    from mojo.serializers.core import OptimizedGraphSerializer, SerializerManager
+
+    # Direct usage
+    serializer = OptimizedGraphSerializer(instance, graph="detail")
+    data = serializer.serialize()
+
+    # Via manager
+    manager = SerializerManager()
+    serializer = manager.get_serializer(instance, graph="list")
+"""
+
+# Import core components
+from .serializer import OptimizedGraphSerializer
+from .manager import (
+    SerializerManager,
+    get_serializer_manager,
+    register_serializer,
+    set_default_serializer,
+    serialize,
+    to_json,
+    to_response,
+    get_performance_stats,
+    clear_serializer_caches,
+    benchmark_serializers,
+    list_serializers,
+    HAS_UJSON,
+    UJSON_VERSION
+)
+
+# Import cache system
+from .cache import (
+    get_cache_backend,
+    get_cache_key,
+    get_model_cache_ttl,
+    get_cache_stats,
+    clear_all_caches,
+    HAS_UJSON,
+    UJSON_VERSION
+)
+
+# Core serializer exports
+__all__ = [
+    # Main serializer
+    'OptimizedGraphSerializer',
+
+    # Manager
+    'SerializerManager',
+    'get_serializer_manager',
+
+    # Registration functions
+    'register_serializer',
+    'set_default_serializer',
+
+    # Convenience functions
+    'serialize',
+    'to_json',
+    'to_response',
+
+    # Performance monitoring
+    'get_performance_stats',
+    'clear_serializer_caches',
+    'benchmark_serializers',
+    'list_serializers',
+
+    # Cache system
+    'get_cache_backend',
+    'get_cache_key',
+    'get_model_cache_ttl',
+    'get_cache_stats',
+    'clear_all_caches',
+
+    # Performance info
+    'HAS_UJSON',
+    'UJSON_VERSION',
+]
+
+# Version info
+__version__ = "1.0.0"

mojo/serializers/core/cache/__init__.py

@@ -0,0 +1,121 @@
+"""
+Django-MOJO Cache System for Serializers
+
+Provides pluggable cache backends for high-performance serialization with intelligent
+TTL management based on RestMeta.GRAPHS configuration.
+
+Supported Backends:
+- MemoryCacheBackend: In-process LRU cache with TTL support
+- RedisCacheBackend: Distributed Redis-based caching (future)
+- DisabledCacheBackend: No-op cache for development/testing
+
+Key Features:
+- RestMeta.cache_ttl configuration per model/graph
+- LRU eviction with configurable size limits
+- JSON serialization for Redis compatibility
+- Thread-safe operations
+- Safe defaults (cache_ttl=0 means no caching)
+
+Usage:
+    from mojo.serializers.core.cache import get_cache_backend
+
+    cache = get_cache_backend()
+
+    # Get cached item (returns None if not found/expired)
+    data = cache.get("Event_123_default")
+
+    # Set with TTL from RestMeta configuration
+    cache.set("Event_123_default", serialized_data, ttl=300)
+
+Configuration:
+    MOJO_SERIALIZER_CACHE = {
+        'backend': 'memory',  # 'memory', 'redis', 'disabled'
+        'memory': {
+            'max_size': 5000,
+            'enable_stats': True
+        },
+        'redis': {  # Future implementation
+            'host': 'localhost',
+            'port': 6379,
+            'key_prefix': 'mojo:serializer:'
+        }
+    }
+
+RestMeta Configuration:
+    class MyModel(MojoModel):
+        class RestMeta:
+            GRAPHS = {
+                "default": {
+                    "fields": ["id", "name"],
+                    "cache_ttl": 300  # 5 minutes
+                },
+                "realtime": {
+                    "fields": ["id", "status"],
+                    "cache_ttl": 0  # No caching (default)
+                }
+            }
+"""
+
+from .base import CacheBackend
+from .memory import MemoryCacheBackend
+from .redis import RedisCacheBackend
+from .disabled import DisabledCacheBackend
+from .backends import (
+    get_cache_backend,
+    create_cache_backend,
+    reset_cache_backend,
+    get_available_backends,
+    test_backend_connectivity,
+    get_cache_health,
+    validate_cache_config
+)
+
+from .utils import (
+    get_cache_key,
+    get_model_cache_ttl,
+    get_cache_stats,
+    clear_all_caches
+)
+
+# Check ujson availability for performance optimization
+try:
+    import ujson
+    HAS_UJSON = True
+    UJSON_VERSION = getattr(ujson, '__version__', 'unknown')
+except ImportError:
+    ujson = None
+    HAS_UJSON = False
+    UJSON_VERSION = None
+
+# Main exports
+__all__ = [
+    # Backend classes
+    'CacheBackend',
+    'MemoryCacheBackend',
+    'RedisCacheBackend',
+    'DisabledCacheBackend',
+
+    # Factory functions
+    'get_cache_backend',
+    'create_cache_backend',
+    'reset_cache_backend',
+
+    # Backend management
+    'get_available_backends',
+    'test_backend_connectivity',
+    'get_cache_health',
+    'validate_cache_config',
+
+    # Utilities
+    'get_cache_key',
+    'get_model_cache_ttl',
+    'get_cache_stats',
+    'clear_all_caches',
+
+    # Performance info
+    'HAS_UJSON',
+    'UJSON_VERSION',
+]
+
+# Version info
+__version__ = "1.0.0"