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

mojo/apps/account/management/commands/serializer_admin.py

@@ -0,0 +1,531 @@
+"""
+Django management command for serializer administration and benchmarking.
+
+Provides comprehensive serializer management capabilities including:
+- Performance benchmarking and comparison
+- Serializer registration and configuration
+- Cache management and statistics
+- Health checks and diagnostics
+
+Usage:
+    # List all registered serializers
+    python manage.py serializer_admin list
+
+    # Benchmark serializers
+    python manage.py serializer_admin benchmark --model MyModel --count 1000
+
+    # Set default serializer
+    python manage.py serializer_admin set-default optimized
+
+    # Get performance statistics
+    python manage.py serializer_admin stats
+
+    # Clear caches
+    python manage.py serializer_admin clear-cache
+"""
+
+import time
+import json
+from django.core.management.base import BaseCommand, CommandError
+from django.apps import apps
+from django.db import models
+from django.core.management import color
+
+from mojo.serializers import (
+    get_serializer_manager,
+    get_performance_stats,
+    clear_serializer_caches,
+    benchmark_serializers,
+    list_serializers,
+    set_default_serializer
+)
+
+
+class Command(BaseCommand):
+    help = 'Manage MOJO serializers: benchmark, configure, and monitor performance'
+
+    def add_arguments(self, parser):
+        """Add command line arguments."""
+
+        subparsers = parser.add_subparsers(dest='action', help='Available actions')
+
+        # List serializers
+        list_parser = subparsers.add_parser('list', help='List all registered serializers')
+        list_parser.add_argument(
+            '--detail',
+            action='store_true',
+            help='Show detailed information about each serializer'
+        )
+
+        # Benchmark serializers
+        bench_parser = subparsers.add_parser('benchmark', help='Benchmark serializer performance')
+        bench_parser.add_argument(
+            '--model',
+            type=str,
+            required=True,
+            help='Model name to benchmark (format: app.ModelName or ModelName)'
+        )
+        bench_parser.add_argument(
+            '--count',
+            type=int,
+            default=100,
+            help='Number of objects to serialize (default: 100)'
+        )
+        bench_parser.add_argument(
+            '--graph',
+            type=str,
+            default='default',
+            help='Graph configuration to use (default: "default")'
+        )
+        bench_parser.add_argument(
+            '--iterations',
+            type=int,
+            default=5,
+            help='Number of benchmark iterations (default: 5)'
+        )
+        bench_parser.add_argument(
+            '--serializers',
+            nargs='+',
+            help='Specific serializers to benchmark (default: all)'
+        )
+        bench_parser.add_argument(
+            '--output-json',
+            type=str,
+            help='Save results to JSON file'
+        )
+
+        # Set default serializer
+        default_parser = subparsers.add_parser('set-default', help='Set default serializer')
+        default_parser.add_argument(
+            'serializer_name',
+            type=str,
+            help='Name of serializer to set as default'
+        )
+
+        # Performance statistics
+        stats_parser = subparsers.add_parser('stats', help='Show performance statistics')
+        stats_parser.add_argument(
+            '--clear',
+            action='store_true',
+            help='Clear statistics after showing them'
+        )
+        stats_parser.add_argument(
+            '--json',
+            action='store_true',
+            help='Output statistics as JSON'
+        )
+
+        # Cache management
+        cache_parser = subparsers.add_parser('clear-cache', help='Clear serializer caches')
+        cache_parser.add_argument(
+            '--serializer',
+            type=str,
+            help='Clear cache for specific serializer (default: all)'
+        )
+
+        # Health check
+        health_parser = subparsers.add_parser('health', help='Run serializer health checks')
+        health_parser.add_argument(
+            '--model',
+            type=str,
+            help='Test specific model (format: app.ModelName or ModelName)'
+        )
+
+        # Test serializers
+        test_parser = subparsers.add_parser('test', help='Test serializer functionality')
+        test_parser.add_argument(
+            '--model',
+            type=str,
+            required=True,
+            help='Model to test (format: app.ModelName or ModelName)'
+        )
+        test_parser.add_argument(
+            '--graph',
+            type=str,
+            default='default',
+            help='Graph configuration to test'
+        )
+
+    def handle(self, *args, **options):
+        """Handle command execution."""
+        action = options.get('action')
+
+        if not action:
+            self.print_help()
+            return
+
+        # Route to appropriate handler
+        handler_map = {
+            'list': self.handle_list,
+            'benchmark': self.handle_benchmark,
+            'set-default': self.handle_set_default,
+            'stats': self.handle_stats,
+            'clear-cache': self.handle_clear_cache,
+            'health': self.handle_health,
+            'test': self.handle_test,
+        }
+
+        handler = handler_map.get(action)
+        if handler:
+            try:
+                handler(options)
+            except Exception as e:
+                raise CommandError(f"Error executing {action}: {str(e)}")
+        else:
+            raise CommandError(f"Unknown action: {action}")
+
+    def handle_list(self, options):
+        """List all registered serializers."""
+        serializers = list_serializers()
+
+        if not serializers:
+            self.stdout.write(
+                self.style.WARNING('No serializers registered')
+            )
+            return
+
+        self.stdout.write(
+            self.style.SUCCESS('Registered Serializers:')
+        )
+
+        for name, info in serializers.items():
+            status = " (DEFAULT)" if info['is_default'] else ""
+            self.stdout.write(f"  • {name}{status}")
+
+            if options.get('detail'):
+                self.stdout.write(f"    Class: {info['class_name']}")
+                self.stdout.write(f"    Description: {info['description']}")
+
+    def handle_benchmark(self, options):
+        """Benchmark serializer performance."""
+        model_class = self.get_model_class(options['model'])
+        count = options['count']
+        graph = options['graph']
+        iterations = options['iterations']
+        serializer_types = options.get('serializers')
+
+        # Check if model has enough instances
+        total_instances = model_class.objects.count()
+        if total_instances < count:
+            self.stdout.write(
+                self.style.WARNING(
+                    f"Model {model_class.__name__} only has {total_instances} instances, "
+                    f"but {count} requested. Using available instances."
+                )
+            )
+            count = min(count, total_instances)
+
+        if count == 0:
+            raise CommandError(f"No instances found for model {model_class.__name__}")
+
+        # Get test queryset
+        test_queryset = model_class.objects.all()[:count]
+
+        self.stdout.write(
+            self.style.SUCCESS(
+                f"Benchmarking serializers with {count} {model_class.__name__} instances"
+            )
+        )
+        self.stdout.write(f"Graph: {graph}")
+        self.stdout.write(f"Iterations: {iterations}")
+
+        # Run benchmark
+        try:
+            results = benchmark_serializers(
+                instance=test_queryset,
+                graph=graph,
+                serializer_types=serializer_types,
+                iterations=iterations
+            )
+
+            # Display results
+            self.display_benchmark_results(results)
+
+            # Save to JSON if requested
+            if options.get('output_json'):
+                self.save_benchmark_results(results, options['output_json'])
+
+        except Exception as e:
+            raise CommandError(f"Benchmark failed: {str(e)}")
+
+    def handle_set_default(self, options):
+        """Set default serializer."""
+        serializer_name = options['serializer_name']
+
+        if set_default_serializer(serializer_name):
+            self.stdout.write(
+                self.style.SUCCESS(
+                    f"Default serializer set to: {serializer_name}"
+                )
+            )
+        else:
+            raise CommandError(f"Failed to set default serializer to {serializer_name}")
+
+    def handle_stats(self, options):
+        """Show performance statistics."""
+        stats = get_performance_stats()
+
+        if options.get('json'):
+            self.stdout.write(json.dumps(stats, indent=2))
+        else:
+            self.display_stats(stats)
+
+        if options.get('clear'):
+            # Clear statistics if requested
+            manager = get_serializer_manager()
+            if hasattr(manager, 'reset_performance_stats'):
+                manager.reset_performance_stats()
+            self.stdout.write(
+                self.style.SUCCESS("Performance statistics cleared")
+            )
+
+    def handle_clear_cache(self, options):
+        """Clear serializer caches."""
+        serializer_name = options.get('serializer')
+
+        if serializer_name:
+            clear_serializer_caches(serializer_name)
+            self.stdout.write(
+                self.style.SUCCESS(f"Cache cleared for {serializer_name}")
+            )
+        else:
+            clear_serializer_caches()
+            self.stdout.write(
+                self.style.SUCCESS("All serializer caches cleared")
+            )
+
+    def handle_health(self, options):
+        """Run serializer health checks."""
+        model_name = options.get('model')
+
+        if model_name:
+            # Test specific model
+            model_class = self.get_model_class(model_name)
+            self.run_model_health_check(model_class)
+        else:
+            # Test all MojoModel subclasses
+            self.run_full_health_check()
+
+    def handle_test(self, options):
+        """Test serializer functionality."""
+        model_class = self.get_model_class(options['model'])
+        graph = options['graph']
+
+        # Get a test instance
+        instance = model_class.objects.first()
+        if not instance:
+            raise CommandError(f"No instances found for model {model_class.__name__}")
+
+        self.stdout.write(
+            self.style.SUCCESS(f"Testing {model_class.__name__} serialization")
+        )
+
+        # Test each registered serializer
+        serializers = list_serializers()
+        manager = get_serializer_manager()
+
+        for serializer_name in serializers.keys():
+            self.stdout.write(f"\nTesting {serializer_name}:")
+
+            try:
+                # Test single instance
+                serializer = manager.get_serializer(instance, graph=graph, serializer_type=serializer_name)
+                data = serializer.serialize()
+                json_output = serializer.to_json()
+
+                self.stdout.write(
+                    self.style.SUCCESS(f"  ✓ Single instance: {len(str(data))} chars")
+                )
+
+                # Test queryset
+                queryset = model_class.objects.all()[:5]  # Test with 5 instances
+                serializer = manager.get_serializer(queryset, graph=graph, serializer_type=serializer_name, many=True)
+                list_data = serializer.serialize()
+                list_json = serializer.to_json()
+
+                self.stdout.write(
+                    self.style.SUCCESS(f"  ✓ QuerySet ({len(list_data)} items): {len(str(list_json))} chars")
+                )
+
+            except Exception as e:
+                self.stdout.write(
+                    self.style.ERROR(f"  ✗ Failed: {str(e)}")
+                )
+
+    def get_model_class(self, model_string):
+        """Get model class from string."""
+        try:
+            if '.' in model_string:
+                app_label, model_name = model_string.split('.', 1)
+                return apps.get_model(app_label, model_name)
+            else:
+                # Try to find model in any app
+                for app_config in apps.get_app_configs():
+                    try:
+                        return app_config.get_model(model_string)
+                    except LookupError:
+                        continue
+                raise CommandError(f"Model '{model_string}' not found")
+        except Exception as e:
+            raise CommandError(f"Invalid model specification '{model_string}': {str(e)}")
+
+    def display_benchmark_results(self, results):
+        """Display benchmark results in a formatted table."""
+        if not results:
+            self.stdout.write(self.style.WARNING("No benchmark results"))
+            return
+
+        self.stdout.write("\nBenchmark Results:")
+        self.stdout.write("=" * 80)
+
+        # Table header
+        header = f"{'Serializer':<15} {'Avg Time':<12} {'Min Time':<12} {'Max Time':<12} {'Obj/Sec':<10}"
+        self.stdout.write(header)
+        self.stdout.write("-" * 80)
+
+        # Sort by average time
+        sorted_results = sorted(
+            results.items(),
+            key=lambda x: x[1].get('avg_time', float('inf'))
+        )
+
+        for name, stats in sorted_results:
+            if 'error' in stats:
+                row = f"{name:<15} {stats['error']:<50}"
+                self.stdout.write(self.style.ERROR(row))
+            else:
+                avg_time = f"{stats['avg_time']:.4f}s"
+                min_time = f"{stats['min_time']:.4f}s"
+                max_time = f"{stats['max_time']:.4f}s"
+                obj_per_sec = f"{stats.get('objects_per_second', 0):.1f}"
+
+                row = f"{name:<15} {avg_time:<12} {min_time:<12} {max_time:<12} {obj_per_sec:<10}"
+                self.stdout.write(row)
+
+                if stats.get('errors', 0) > 0:
+                    self.stdout.write(
+                        self.style.WARNING(f"  └─ {stats['errors']} errors occurred")
+                    )
+
+    def display_stats(self, stats):
+        """Display performance statistics."""
+        self.stdout.write(self.style.SUCCESS("Serializer Performance Statistics:"))
+
+        # Default serializer
+        default_serializer = stats.get('default_serializer')
+        if default_serializer:
+            self.stdout.write(f"Default Serializer: {default_serializer}")
+
+        # Registered serializers
+        registered = stats.get('registered_serializers', {})
+        if registered:
+            self.stdout.write(f"Registered Serializers: {len(registered)}")
+            for name, info in registered.items():
+                status = " (default)" if info['is_default'] else ""
+                self.stdout.write(f"  • {name}{status}")
+
+        # Usage statistics
+        usage_stats = stats.get('usage_stats', {})
+        if usage_stats:
+            self.stdout.write("\nUsage Statistics:")
+            for serializer, data in usage_stats.items():
+                self.stdout.write(
+                    f"  {serializer}: {data['count']} uses, "
+                    f"{data['total_objects']} objects serialized"
+                )
+
+        # Individual serializer stats
+        for key, value in stats.items():
+            if key.endswith('_stats') and isinstance(value, dict):
+                serializer_name = key.replace('_stats', '')
+                self.stdout.write(f"\n{serializer_name.title()} Stats:")
+                for stat_key, stat_value in value.items():
+                    self.stdout.write(f"  {stat_key}: {stat_value}")
+
+    def save_benchmark_results(self, results, filename):
+        """Save benchmark results to JSON file."""
+        try:
+            with open(filename, 'w') as f:
+                json.dump({
+                    'timestamp': time.time(),
+                    'results': results
+                }, f, indent=2)
+            self.stdout.write(
+                self.style.SUCCESS(f"Results saved to {filename}")
+            )
+        except Exception as e:
+            self.stdout.write(
+                self.style.ERROR(f"Failed to save results: {str(e)}")
+            )
+
+    def run_model_health_check(self, model_class):
+        """Run health check for specific model."""
+        self.stdout.write(f"Health check for {model_class.__name__}:")
+
+        # Check if model has RestMeta
+        if hasattr(model_class, 'RestMeta'):
+            self.stdout.write(self.style.SUCCESS("  ✓ RestMeta found"))
+
+            # Check graphs
+            if hasattr(model_class.RestMeta, 'GRAPHS'):
+                graphs = model_class.RestMeta.GRAPHS
+                self.stdout.write(f"  ✓ {len(graphs)} graphs configured: {list(graphs.keys())}")
+            else:
+                self.stdout.write(self.style.WARNING("  ⚠ No GRAPHS configured"))
+        else:
+            self.stdout.write(self.style.WARNING("  ⚠ No RestMeta found"))
+
+        # Test serialization if instances exist
+        if model_class.objects.exists():
+            instance = model_class.objects.first()
+            manager = get_serializer_manager()
+
+            try:
+                serializer = manager.get_serializer(instance)
+                data = serializer.serialize()
+                self.stdout.write(self.style.SUCCESS("  ✓ Serialization successful"))
+            except Exception as e:
+                self.stdout.write(self.style.ERROR(f"  ✗ Serialization failed: {str(e)}"))
+        else:
+            self.stdout.write(self.style.WARNING("  ⚠ No instances available for testing"))
+
+    def run_full_health_check(self):
+        """Run health check for all models."""
+        self.stdout.write("Running full serializer health check...")
+
+        # Import MojoModel to check for subclasses
+        try:
+            from mojo.models.rest import MojoModel
+
+            # Find all MojoModel subclasses
+            mojo_models = []
+            for app_config in apps.get_app_configs():
+                for model in app_config.get_models():
+                    if hasattr(model, 'RestMeta') or 'MojoModel' in [c.__name__ for c in model.__mro__]:
+                        mojo_models.append(model)
+
+            if not mojo_models:
+                self.stdout.write(self.style.WARNING("No MojoModel subclasses found"))
+                return
+
+            self.stdout.write(f"Found {len(mojo_models)} models to check\n")
+
+            for model in mojo_models:
+                self.run_model_health_check(model)
+                self.stdout.write("")  # Empty line
+
+        except ImportError:
+            self.stdout.write(self.style.ERROR("Could not import MojoModel"))
+
+    def print_help(self):
+        """Print command help."""
+        self.stdout.write("MOJO Serializer Administration Command")
+        self.stdout.write("\nAvailable actions:")
+        self.stdout.write("  list        - List registered serializers")
+        self.stdout.write("  benchmark   - Benchmark serializer performance")
+        self.stdout.write("  set-default - Set default serializer")
+        self.stdout.write("  stats       - Show performance statistics")
+        self.stdout.write("  clear-cache - Clear serializer caches")
+        self.stdout.write("  health      - Run health checks")
+        self.stdout.write("  test        - Test serializer functionality")
+        self.stdout.write("\nUse 'python manage.py serializer_admin <action> --help' for more details")

mojo/apps/account/migrations/0004_user_avatar.py

@@ -0,0 +1,20 @@
+# Generated by Django 4.2.21 on 2025-06-09 05:37
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('fileman', '0011_alter_filerendition_original_file'),
+        ('account', '0003_group_mojo_secrets_user_mojo_secrets'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='user',
+            name='avatar',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='+', to='fileman.file'),
+        ),
+    ]

mojo/apps/account/migrations/0005_group_last_activity.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.21 on 2025-08-26 16:05
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('account', '0004_user_avatar'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='group',
+            name='last_activity',
+            field=models.DateTimeField(db_index=True, default=None, null=True),
+        ),
+    ]

mojo/apps/account/models/group.py

@@ -1,7 +1,11 @@
 from django.db import models
 from mojo.models import MojoModel, MojoSecrets
 from mojo.helpers import dates
+from mojo.apps import metrics
+from mojo.helpers.settings import settings
 
+GROUP_LAST_ACTIVITY_FREQ = settings.get("GROUP_LAST_ACTIVITY_FREQ", 300)
+METRICS_TIMEZONE = settings.get("METRICS_TIMEZONE", "America/Los_Angeles")
 
 
 class Group(MojoSecrets, MojoModel):
@@ -10,6 +14,7 @@ class Group(MojoSecrets, MojoModel):
     """
     created = models.DateTimeField(auto_now_add=True, editable=False)
     modified = models.DateTimeField(auto_now=True, db_index=True)
+    last_activity = models.DateTimeField(default=None, null=True, db_index=True)
 
     name = models.CharField(max_length=200)
     uuid = models.CharField(max_length=200, null=True, default=None, db_index=True)
@@ -36,6 +41,7 @@ class Group(MojoSecrets, MojoModel):
                     'name',
                     'created',
                     'modified',
+                    'last_activity',
                     'is_active',
                     'kind',
                 ]
@@ -46,15 +52,17 @@ class Group(MojoSecrets, MojoModel):
                     'name',
                     'created',
                     'modified',
+                    'last_activity',
                     'is_active',
                     'kind',
                     'parent',
                     'metadata'
-                ]
+                ],
+                "graphs": {
+                    "parent": "basic"
+                }
             },
-            "graphs": {
-                "parent": "basic"
-            }
+
         }
 
     @property
@@ -68,7 +76,7 @@ class Group(MojoSecrets, MojoModel):
         return dates.get_local_time(self.timezone, dt_utc)
 
     def __str__(self):
-        return self.name
+        return str(self.name)
 
     def has_permission(self, user):
         from mojo.account.models.member import GroupMember
@@ -82,6 +90,14 @@ class Group(MojoSecrets, MojoModel):
             return ms.has_permission(perms)
         return False
 
+    def touch(self):
+        # can't subtract offset-naive and offset-aware datetimes
+        if self.last_activity and not dates.is_today(self.last_activity, METRICS_TIMEZONE):
+            metrics.record("group_activity_day", category="group", min_granularity="days")
+        if self.last_activity is None or dates.has_time_elsapsed(self.last_activity, seconds=GROUP_LAST_ACTIVITY_FREQ):
+            self.last_activity = dates.utcnow()
+            self.atomic_save()
+
     def get_metadata(self):
         # converts our local metadata into an objict
         self.metadata = self.jsonfield_as_objict("metadata")
@@ -94,5 +110,7 @@ class Group(MojoSecrets, MojoModel):
     def on_rest_handle_list(cls, request):
         if cls.rest_check_permission(request, "VIEW_PERMS"):
             return cls.on_rest_list(request)
-        group_ids = request.user.members.values_list('group__id', flat=True)
-        return cls.on_rest_list(request, cls.objects.filter(id__in=group_ids))
+        if getattr(request.user, 'members') is not None:
+            group_ids = request.user.members.values_list('group__id', flat=True)
+            return cls.on_rest_list(request, cls.objects.filter(id__in=group_ids))
+        return cls.on_rest_list(request, cls.objects.none())