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

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
 ]