django-cfg 1.5.20__py3-none-any.whl → 1.5.31__py3-none-any.whl

django_cfg/apps/integrations/grpc/management/commands/rungrpc.py

@@ -237,7 +237,7 @@ class Command(BaseCommand):
 
         # Import models here to avoid AppRegistryNotReady
         from django_cfg.apps.integrations.grpc.models import GRPCServerStatus
-        from django_cfg.apps.integrations.grpc.services.config_helper import (
+        from django_cfg.apps.integrations.grpc.services.management.config_helper import (
             get_grpc_server_config,
         )
 
@@ -332,8 +332,7 @@ class Command(BaseCommand):
                 discovery.get_registered_services
             )
 
-            server_status = await asyncio.to_thread(
-                GRPCServerStatus.objects.start_server,
+            server_status = await GRPCServerStatus.objects.astart_server(
                 host=host,
                 port=port,
                 pid=os.getpid(),
@@ -344,8 +343,7 @@ class Command(BaseCommand):
 
             # Store registered services in database
             server_status.registered_services = services_metadata
-            await asyncio.to_thread(
-                server_status.save,
+            await server_status.asave(
                 update_fields=["registered_services"]
             )
 
@@ -361,7 +359,7 @@ class Command(BaseCommand):
         # Mark server as running
         if server_status:
             try:
-                await asyncio.to_thread(server_status.mark_running)
+                await server_status.amark_running()
             except Exception as e:
                 self.logger.warning(f"Could not mark server as running: {e}")
 
@@ -425,7 +423,7 @@ class Command(BaseCommand):
         if options.get("test"):
             self.streaming_logger.info("🧪 Sending test Centrifugo event...")
             try:
-                from django_cfg.apps.integrations.grpc.centrifugo.demo import send_demo_event
+                from django_cfg.apps.integrations.grpc.services.centrifugo.demo import send_demo_event
 
                 test_result = await send_demo_event(
                     channel="grpc#rungrpc#startup#test",
@@ -690,7 +688,6 @@ class Command(BaseCommand):
             interval: Heartbeat interval in seconds (default: 30)
         """
         from django_cfg.apps.integrations.grpc.models import GRPCServerStatus
-        from asgiref.sync import sync_to_async
 
         try:
             while True:
@@ -701,12 +698,10 @@ class Command(BaseCommand):
                     continue
 
                 try:
-                    # Check if record still exists
-                    record_exists = await sync_to_async(
-                        GRPCServerStatus.objects.filter(
-                            id=self.server_status.id
-                        ).exists
-                    )()
+                    # Check if record still exists (Django 5.2: Native async ORM)
+                    record_exists = await GRPCServerStatus.objects.filter(
+                        id=self.server_status.id
+                    ).aexists()
 
                     if not record_exists:
                         # Record was deleted - re-register server
@@ -722,21 +717,19 @@ class Command(BaseCommand):
                             discovery.get_registered_services
                         )
 
-                        # Re-register server
-                        new_server_status = await asyncio.to_thread(
-                            GRPCServerStatus.objects.start_server,
+                        # Re-register server (Django 5.2: Native async ORM)
+                        new_server_status = await GRPCServerStatus.objects.astart_server(
                             **self.server_config
                         )
 
                         # Store registered services
                         new_server_status.registered_services = services_metadata
-                        await asyncio.to_thread(
-                            new_server_status.save,
+                        await new_server_status.asave(
                             update_fields=["registered_services"]
                         )
 
-                        # Mark as running
-                        await asyncio.to_thread(new_server_status.mark_running)
+                        # Mark as running (Django 5.2: Native async ORM)
+                        await new_server_status.amark_running()
 
                         # Update reference
                         self.server_status = new_server_status
@@ -745,8 +738,8 @@ class Command(BaseCommand):
                             f"✅ Successfully re-registered server (ID: {new_server_status.id})"
                         )
                     else:
-                        # Record exists - just update heartbeat
-                        await asyncio.to_thread(self.server_status.mark_running)
+                        # Record exists - just update heartbeat (Django 5.2: Native async ORM)
+                        await self.server_status.amark_running()
                         self.logger.debug(f"Heartbeat updated (interval: {interval}s)")
 
                 except Exception as e:
@@ -785,17 +778,11 @@ class Command(BaseCommand):
 
             self.stdout.write("\n🛑 Shutting down gracefully...")
 
-            # Mark server as stopping
+            # Mark server as stopping (sync context - signal handlers are sync)
             if server_status:
                 try:
-                    import django
-                    if django.VERSION >= (3, 0):
-                        from asgiref.sync import sync_to_async
-                        # Run in sync context
-                        try:
-                            server_status.mark_stopping()
-                        except:
-                            pass
+                    # ✅ Use Django 5.2+ async ORM instead of sync_to_async
+                    asyncio.create_task(server_status.amark_stopping())
                 except Exception as e:
                     self.logger.warning(f"Could not mark server as stopping: {e}")
 
@@ -807,12 +794,11 @@ class Command(BaseCommand):
             except Exception as e:
                 self.logger.error(f"Error stopping server: {e}")
 
-            # Mark server as stopped (async-safe)
+            # Mark server as stopped (async-safe, Django 5.2: Native async ORM)
             if server_status:
                 try:
-                    from asgiref.sync import sync_to_async
-                    # Wrap sync DB operation in sync_to_async
-                    asyncio.create_task(sync_to_async(server_status.mark_stopped)())
+                    # Use native async method
+                    asyncio.create_task(server_status.amark_stopped())
                 except Exception as e:
                     self.logger.warning(f"Could not mark server as stopped: {e}")
 

django_cfg/apps/integrations/grpc/managers/grpc_request_log.py

@@ -207,6 +207,48 @@ class GRPCRequestLogManager(models.Manager):
             ]
         )
 
+    async def amark_success(
+        self,
+        log_instance,
+        duration_ms: int | None = None,
+        response_size: int | None = None,
+        response_data: dict | None = None,
+    ):
+        """
+        Mark request as successful (ASYNC - Django 5.2).
+
+        Args:
+            log_instance: GRPCRequestLog instance
+            duration_ms: Duration in milliseconds
+            response_size: Response size in bytes
+            response_data: Response data
+        """
+        from ..models import GRPCRequestLog
+
+        log_instance.status = GRPCRequestLog.StatusChoices.SUCCESS
+        log_instance.grpc_status_code = "OK"
+        log_instance.completed_at = timezone.now()
+
+        if duration_ms is not None:
+            log_instance.duration_ms = duration_ms
+
+        if response_size is not None:
+            log_instance.response_size = response_size
+
+        if response_data is not None:
+            log_instance.response_data = response_data
+
+        await log_instance.asave(
+            update_fields=[
+                "status",
+                "grpc_status_code",
+                "completed_at",
+                "duration_ms",
+                "response_size",
+                "response_data",
+            ]
+        )
+
     def mark_error(
         self,
         log_instance,
@@ -249,6 +291,48 @@ class GRPCRequestLogManager(models.Manager):
             ]
         )
 
+    async def amark_error(
+        self,
+        log_instance,
+        grpc_status_code: str,
+        error_message: str,
+        error_details: dict | None = None,
+        duration_ms: int | None = None,
+    ):
+        """
+        Mark request as failed (ASYNC - Django 5.2).
+
+        Args:
+            log_instance: GRPCRequestLog instance
+            grpc_status_code: gRPC status code
+            error_message: Error message
+            error_details: Additional error details
+            duration_ms: Duration in milliseconds
+        """
+        from ..models import GRPCRequestLog
+
+        log_instance.status = GRPCRequestLog.StatusChoices.ERROR
+        log_instance.grpc_status_code = grpc_status_code
+        log_instance.error_message = error_message
+        log_instance.completed_at = timezone.now()
+
+        if error_details is not None:
+            log_instance.error_details = error_details
+
+        if duration_ms is not None:
+            log_instance.duration_ms = duration_ms
+
+        await log_instance.asave(
+            update_fields=[
+                "status",
+                "grpc_status_code",
+                "error_message",
+                "error_details",
+                "completed_at",
+                "duration_ms",
+            ]
+        )
+
     def mark_cancelled(
         self,
         log_instance,

django_cfg/apps/integrations/grpc/managers/grpc_server_status.py

@@ -32,7 +32,7 @@ class GRPCServerStatusManager(models.Manager):
         enable_health_check: bool = True,
     ):
         """
-        Start tracking a new server instance.
+        Start tracking a new server instance (SYNC).
 
         Args:
             host: Server host address
@@ -88,9 +88,75 @@ class GRPCServerStatusManager(models.Manager):
 
         return status
 
+    async def astart_server(
+        self,
+        host: str,
+        port: int,
+        pid: int = None,
+        max_workers: int = 10,
+        enable_reflection: bool = False,
+        enable_health_check: bool = True,
+    ):
+        """
+        Start tracking a new server instance (ASYNC - Django 5.2).
+
+        Args:
+            host: Server host address
+            port: Server port
+            pid: Process ID (defaults to current process)
+            max_workers: Maximum worker threads
+            enable_reflection: Whether reflection is enabled
+            enable_health_check: Whether health check is enabled
+
+        Returns:
+            GRPCServerStatus instance
+
+        Example:
+            >>> status = await GRPCServerStatus.objects.astart_server(
+            ...     host="[::]",
+            ...     port=50051,
+            ...     pid=12345
+            ... )
+            >>> status.is_running
+            True
+
+        Note:
+            External/internal server detection is automatic based on env_mode.
+            Production mode assumes external server (Docker), dev/test assumes local.
+        """
+        if pid is None:
+            pid = os.getpid()
+
+        hostname = socket.gethostname()
+        address = f"{host}:{port}"
+        instance_id = f"{hostname}:{port}:{pid}"
+
+        # Mark any existing server at this address as stopped (async)
+        await self.astop_servers_at_address(address)
+
+        # Create or update server status (handles restart with same instance_id)
+        status, created = await self.aupdate_or_create(
+            instance_id=instance_id,
+            defaults={
+                "host": host,
+                "port": port,
+                "address": address,
+                "pid": pid,
+                "hostname": hostname,
+                "status": self.model.StatusChoices.STARTING,
+                "max_workers": max_workers,
+                "enable_reflection": enable_reflection,
+                "enable_health_check": enable_health_check,
+                "started_at": timezone.now(),
+                "last_heartbeat": timezone.now(),
+            },
+        )
+
+        return status
+
     def get_current_server(self, address: str = None) -> Optional["GRPCServerStatus"]:
         """
-        Get the currently running server.
+        Get the currently running server (SYNC).
 
         Args:
             address: Optional address filter (host:port)
@@ -122,6 +188,40 @@ class GRPCServerStatusManager(models.Manager):
 
         return None
 
+    async def aget_current_server(self, address: str = None) -> Optional["GRPCServerStatus"]:
+        """
+        Get the currently running server (ASYNC - Django 5.2).
+
+        Args:
+            address: Optional address filter (host:port)
+
+        Returns:
+            GRPCServerStatus instance or None
+
+        Example:
+            >>> server = await GRPCServerStatus.objects.aget_current_server()
+            >>> if server and server.is_running:
+            ...     print(f"Server running for {server.uptime_display}")
+        """
+        queryset = self.filter(
+            status__in=[
+                self.model.StatusChoices.STARTING,
+                self.model.StatusChoices.RUNNING,
+            ]
+        )
+
+        if address:
+            queryset = queryset.filter(address=address)
+
+        # Get most recent (Django 5.2: afirst)
+        server = await queryset.order_by("-started_at").afirst()
+
+        # Verify it's actually running
+        if server and server.is_running:
+            return server
+
+        return None
+
     def get_running_servers(self):
         """
         Get all currently running servers.
@@ -183,7 +283,7 @@ class GRPCServerStatusManager(models.Manager):
 
     def stop_servers_at_address(self, address: str):
         """
-        Stop all servers at a specific address.
+        Stop all servers at a specific address (SYNC).
 
         Args:
             address: Server address (host:port)
@@ -202,6 +302,29 @@ class GRPCServerStatusManager(models.Manager):
         for server in servers:
             server.mark_stopped("Replaced by new server instance")
 
+    async def astop_servers_at_address(self, address: str):
+        """
+        Stop all servers at a specific address (ASYNC - Django 5.2).
+
+        Args:
+            address: Server address (host:port)
+
+        Example:
+            >>> await GRPCServerStatus.objects.astop_servers_at_address("[::]:50051")
+        """
+        servers = []
+        async for server in self.filter(
+            address=address,
+            status__in=[
+                self.model.StatusChoices.STARTING,
+                self.model.StatusChoices.RUNNING,
+            ],
+        ):
+            servers.append(server)
+
+        for server in servers:
+            await server.amark_stopped("Replaced by new server instance")
+
     def cleanup_stale_servers(self, hours: int = 24):
         """
         Mark stale servers as stopped.

django_cfg/apps/integrations/grpc/models/grpc_api_key.py

@@ -184,11 +184,17 @@ class GrpcApiKey(models.Model):
         return f"{self.key[:4]}...{self.key[-4:]}"
 
     def mark_used(self) -> None:
-        """Mark this key as used (update last_used_at and increment counter)."""
+        """Mark this key as used (update last_used_at and increment counter) (SYNC)."""
         self.last_used_at = timezone.now()
         self.request_count += 1
         self.save(update_fields=["last_used_at", "request_count"])
 
+    async def amark_used(self) -> None:
+        """Mark this key as used (update last_used_at and increment counter) (ASYNC - Django 5.2)."""
+        self.last_used_at = timezone.now()
+        self.request_count += 1
+        await self.asave(update_fields=["last_used_at", "request_count"])
+
     def revoke(self) -> None:
         """Revoke this key (set is_active=False)."""
         self.is_active = False

django_cfg/apps/integrations/grpc/models/grpc_server_status.py

@@ -271,24 +271,43 @@ class GRPCServerStatus(models.Model):
             return False
 
     def mark_running(self):
-        """Mark server as running."""
+        """Mark server as running (SYNC)."""
         self.status = self.StatusChoices.RUNNING
         self.error_message = None
         self.save(update_fields=["status", "error_message", "updated_at", "last_heartbeat"])
 
+    async def amark_running(self):
+        """Mark server as running (ASYNC - Django 5.2)."""
+        self.status = self.StatusChoices.RUNNING
+        self.error_message = None
+        await self.asave(update_fields=["status", "error_message", "updated_at", "last_heartbeat"])
+
     def mark_stopping(self):
-        """Mark server as stopping."""
+        """Mark server as stopping (SYNC)."""
         self.status = self.StatusChoices.STOPPING
         self.save(update_fields=["status", "updated_at", "last_heartbeat"])
 
+    async def amark_stopping(self):
+        """Mark server as stopping (ASYNC - Django 5.2)."""
+        self.status = self.StatusChoices.STOPPING
+        await self.asave(update_fields=["status", "updated_at", "last_heartbeat"])
+
     def mark_stopped(self, error_message: str = None):
-        """Mark server as stopped."""
+        """Mark server as stopped (SYNC)."""
         self.status = self.StatusChoices.STOPPED
         self.stopped_at = timezone.now()
         if error_message:
             self.error_message = error_message
         self.save(update_fields=["status", "stopped_at", "error_message", "updated_at"])
 
+    async def amark_stopped(self, error_message: str = None):
+        """Mark server as stopped (ASYNC - Django 5.2)."""
+        self.status = self.StatusChoices.STOPPED
+        self.stopped_at = timezone.now()
+        if error_message:
+            self.error_message = error_message
+        await self.asave(update_fields=["status", "stopped_at", "error_message", "updated_at"])
+
     def mark_error(self, error_message: str):
         """Mark server as error."""
         self.status = self.StatusChoices.ERROR

django_cfg/apps/integrations/grpc/services/__init__.py

@@ -1,36 +1,117 @@
 """
 gRPC services utilities.
 
-Provides service discovery, base classes, config helpers, service registry,
-monitoring, and testing services for gRPC.
-"""
+Provides organized gRPC service components:
+- **streaming**: Universal bidirectional streaming (NEW)
+- **routing**: Cross-process command routing (NEW)
+- **client**: gRPC client utilities
+- **discovery**: Service discovery and registry
+- **management**: Proto files and config management
+- **monitoring**: Service monitoring and testing
+- **rendering**: Content generation (charts, etc.)
+- **base**: Base service classes
+
+**Quick Imports**:
+```python
+# New universal components
+from django_cfg.apps.integrations.grpc.services.streaming import (
+    BidirectionalStreamingService,
+    ConfigPresets,
+)
 
-from .base import AuthRequiredService, BaseService, ReadOnlyService
-from .config_helper import (
-    get_enabled_apps,
-    get_grpc_auth_config,
-    get_grpc_config,
-    get_grpc_config_or_default,
-    get_grpc_server_config,
-    is_grpc_enabled,
+from django_cfg.apps.integrations.grpc.services.routing import (
+    CrossProcessCommandRouter,
+    CrossProcessConfig,
 )
-from .discovery import ServiceDiscovery, discover_and_register_services
-from .grpc_client import DynamicGRPCClient
-from .monitoring_service import MonitoringService
-from .proto_files_manager import ProtoFilesManager
-from .service_registry import ServiceRegistryManager
-from .testing_service import TestingService
+
+# Existing services
+from django_cfg.apps.integrations.grpc.services import (
+    BaseService,
+    ServiceDiscovery,
+)
+```
+
+Created: 2025-11-07
+Status: %%PRODUCTION%%
+"""
+
+# Lazy imports to avoid Django initialization on import
+# Import only when actually accessed via __getattr__
+
+def __getattr__(name):
+    """Lazy import to avoid Django setup on package import."""
+
+    # Base service classes
+    if name in ('AuthRequiredService', 'BaseService', 'ReadOnlyService'):
+        from .base import AuthRequiredService, BaseService, ReadOnlyService
+        return locals()[name]
+
+    # Management utilities
+    if name in ('get_enabled_apps', 'get_grpc_auth_config', 'get_grpc_config',
+                'get_grpc_config_or_default', 'get_grpc_server_config', 'is_grpc_enabled'):
+        from .management.config_helper import (
+            get_enabled_apps,
+            get_grpc_auth_config,
+            get_grpc_config,
+            get_grpc_config_or_default,
+            get_grpc_server_config,
+            is_grpc_enabled,
+        )
+        return locals()[name]
+
+    if name == 'ProtoFilesManager':
+        from .management.proto_manager import ProtoFilesManager
+        return ProtoFilesManager
+
+    # Discovery
+    if name == 'ServiceDiscovery':
+        from .discovery.discovery import ServiceDiscovery
+        return ServiceDiscovery
+
+    if name == 'discover_and_register_services':
+        from .discovery.discovery import discover_and_register_services
+        return discover_and_register_services
+
+    if name == 'ServiceRegistryManager':
+        from .discovery.registry import ServiceRegistryManager
+        return ServiceRegistryManager
+
+    # Client
+    if name == 'DynamicGRPCClient':
+        from .client.client import DynamicGRPCClient
+        return DynamicGRPCClient
+
+    # Monitoring
+    if name == 'MonitoringService':
+        from .monitoring.monitoring import MonitoringService
+        return MonitoringService
+
+    if name == 'TestingService':
+        from .monitoring.testing import TestingService
+        return TestingService
+
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
 
 __all__ = [
+    # Base classes
     "BaseService",
     "ReadOnlyService",
     "AuthRequiredService",
+
+    # Discovery
     "ServiceDiscovery",
     "discover_and_register_services",
     "ServiceRegistryManager",
+
+    # Monitoring
     "MonitoringService",
     "TestingService",
+
+    # Client
     "DynamicGRPCClient",
+
+    # Management
     "ProtoFilesManager",
     "get_grpc_config",
     "get_grpc_config_or_default",
@@ -38,4 +119,8 @@ __all__ = [
     "get_grpc_server_config",
     "get_grpc_auth_config",
     "get_enabled_apps",
+
+    # New components available via subpackages:
+    # - streaming: BidirectionalStreamingService, ConfigPresets, etc.
+    # - routing: CrossProcessCommandRouter, CrossProcessConfig
 ]