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

django_cfg/__init__.py

@@ -32,7 +32,7 @@ Example:
 default_app_config = "django_cfg.apps.DjangoCfgConfig"
 
 # Version information
-__version__ = "1.5.20"
+__version__ = "1.5.29"
 __license__ = "MIT"
 
 # Setup warnings debug early (checks env var only at this point)

django_cfg/apps/integrations/centrifugo/__init__.py

@@ -23,6 +23,7 @@ Example:
 """
 
 from .services.client.client import CentrifugoClient, get_centrifugo_client, PublishResponse
+from .services.client.direct_client import DirectCentrifugoClient
 from .services.client.config import DjangoCfgCentrifugoConfig
 from .services.client.exceptions import (
     CentrifugoBaseException,
@@ -42,6 +43,7 @@ __all__ = [
     "DjangoCfgCentrifugoConfig",
     # Client
     "CentrifugoClient",
+    "DirectCentrifugoClient",
     "get_centrifugo_client",
     "PublishResponse",
     # Logging

django_cfg/apps/integrations/centrifugo/services/client/client.py

@@ -396,7 +396,7 @@ class CentrifugoClient:
 
                 error_code = type(last_error).__name__ if last_error else "unknown"
                 error_message = str(last_error) if last_error else "Unknown error"
-                CentrifugoLogger.mark_failed(
+                await CentrifugoLogger.mark_failed_async(
                     log_entry,
                     error_code=error_code,
                     error_message=error_message,

django_cfg/apps/integrations/centrifugo/services/logging.py

@@ -400,6 +400,53 @@ class CentrifugoLogger:
                 extra={"message_id": getattr(log_entry, "message_id", "unknown")},
             )
 
+    @staticmethod
+    async def mark_failed_async(
+        log_entry: Any,
+        error_code: str,
+        error_message: str,
+        duration_ms: int | None = None,
+    ) -> None:
+        """
+        Mark publish operation as failed (async version).
+
+        Args:
+            log_entry: CentrifugoLog instance
+            error_code: Error code
+            error_message: Error message
+            duration_ms: Duration in milliseconds
+        """
+        if log_entry is None:
+            return
+
+        try:
+            from asgiref.sync import sync_to_async
+            from ..models import CentrifugoLog
+
+            await sync_to_async(CentrifugoLog.objects.mark_failed)(
+                log_instance=log_entry,
+                error_code=error_code,
+                error_message=error_message,
+                duration_ms=duration_ms,
+            )
+
+            logger.error(
+                f"Centrifugo publish failed: {log_entry.message_id}",
+                extra={
+                    "message_id": log_entry.message_id,
+                    "channel": log_entry.channel,
+                    "error_code": error_code,
+                    "error_message": error_message,
+                    "duration_ms": duration_ms,
+                },
+            )
+
+        except Exception as e:
+            logger.error(
+                f"Failed to mark Centrifugo log as failed: {e}",
+                extra={"message_id": getattr(log_entry, "message_id", "unknown")},
+            )
+
     @staticmethod
     async def mark_timeout_async(
         log_entry: Any,

django_cfg/apps/integrations/centrifugo/views/admin_api.py

@@ -5,7 +5,6 @@ Proxies requests to Centrifugo server API with authentication and type safety.
 Provides Django endpoints that map to Centrifugo HTTP API methods.
 """
 
-import asyncio
 import httpx
 from django.http import JsonResponse
 from django_cfg.modules.django_logging import get_logger
@@ -113,10 +112,10 @@ class CentrifugoAdminAPIViewSet(AdminAPIMixin, viewsets.ViewSet):
         },
     )
     @action(detail=False, methods=["post"], url_path="info")
-    def info(self, request):
-        """Get Centrifugo server information."""
+    async def info(self, request):
+        """Get Centrifugo server information (ASYNC)."""
         try:
-            result = asyncio.run(self._call_centrifugo_api("info", params={}))
+            result = await self._call_centrifugo_api("info", params={})
 
             # Check for Centrifugo API error
             if "error" in result and result["error"]:
@@ -147,13 +146,13 @@ class CentrifugoAdminAPIViewSet(AdminAPIMixin, viewsets.ViewSet):
         },
     )
     @action(detail=False, methods=["post"], url_path="channels")
-    def channels(self, request):
-        """List active channels."""
+    async def channels(self, request):
+        """List active channels (ASYNC)."""
         try:
             req_data = CentrifugoChannelsRequest(**request.data)
-            result = asyncio.run(self._call_centrifugo_api(
+            result = await self._call_centrifugo_api(
                 "channels", params=req_data.model_dump(exclude_none=True)
-            ))
+            )
 
             # Check for Centrifugo API error
             if "error" in result and result["error"]:
@@ -183,13 +182,13 @@ class CentrifugoAdminAPIViewSet(AdminAPIMixin, viewsets.ViewSet):
         },
     )
     @action(detail=False, methods=["post"], url_path="presence")
-    def presence(self, request):
-        """Get channel presence (active subscribers)."""
+    async def presence(self, request):
+        """Get channel presence (active subscribers) (ASYNC)."""
         try:
             req_data = CentrifugoPresenceRequest(**request.data)
-            result = asyncio.run(self._call_centrifugo_api(
+            result = await self._call_centrifugo_api(
                 "presence", params=req_data.model_dump()
-            ))
+            )
 
             # Check for Centrifugo API error (e.g., code 108 "not available")
             if "error" in result and result["error"]:
@@ -219,13 +218,13 @@ class CentrifugoAdminAPIViewSet(AdminAPIMixin, viewsets.ViewSet):
         },
     )
     @action(detail=False, methods=["post"], url_path="presence-stats")
-    def presence_stats(self, request):
-        """Get channel presence statistics."""
+    async def presence_stats(self, request):
+        """Get channel presence statistics (ASYNC)."""
         try:
             req_data = CentrifugoPresenceStatsRequest(**request.data)
-            result = asyncio.run(self._call_centrifugo_api(
+            result = await self._call_centrifugo_api(
                 "presence_stats", params=req_data.model_dump()
-            ))
+            )
 
             # Check for Centrifugo API error (e.g., code 108 "not available")
             if "error" in result and result["error"]:
@@ -255,13 +254,13 @@ class CentrifugoAdminAPIViewSet(AdminAPIMixin, viewsets.ViewSet):
         },
     )
     @action(detail=False, methods=["post"], url_path="history")
-    def history(self, request):
-        """Get channel message history."""
+    async def history(self, request):
+        """Get channel message history (ASYNC)."""
         try:
             req_data = CentrifugoHistoryRequest(**request.data)
-            result = asyncio.run(self._call_centrifugo_api(
+            result = await self._call_centrifugo_api(
                 "history", params=req_data.model_dump(exclude_none=True)
-            ))
+            )
 
             # Check for Centrifugo API error (e.g., code 108 "not available")
             if "error" in result and result["error"]:
@@ -359,19 +358,17 @@ class CentrifugoAdminAPIViewSet(AdminAPIMixin, viewsets.ViewSet):
                 status=status.HTTP_500_INTERNAL_SERVER_ERROR
             )
 
-    def __del__(self):
-        """Cleanup HTTP client on deletion."""
+    async def cleanup(self):
+        """
+        Explicit async cleanup method for HTTP client.
+
+        Note: Django handles ViewSet lifecycle automatically.
+        This method is provided for explicit cleanup if needed,
+        but httpx.AsyncClient will be garbage collected normally.
+        """
         if self._http_client:
-            import asyncio
-
-            try:
-                loop = asyncio.get_event_loop()
-                if loop.is_running():
-                    loop.create_task(self._http_client.aclose())
-                else:
-                    loop.run_until_complete(self._http_client.aclose())
-            except Exception:
-                pass  # Ignore cleanup errors
+            await self._http_client.aclose()
+            self._http_client = None
 
 
 __all__ = ["CentrifugoAdminAPIViewSet"]

django_cfg/apps/integrations/centrifugo/views/testing_api.py

@@ -5,7 +5,6 @@ Provides endpoints for live testing of Centrifugo integration from dashboard.
 Includes connection tokens, publish proxying, and ACK management.
 """
 
-import asyncio
 import time
 from datetime import datetime, timedelta
 from typing import Any, Dict
@@ -127,23 +126,21 @@ class CentrifugoTestingAPIViewSet(AdminAPIMixin, viewsets.ViewSet):
         },
     )
     @action(detail=False, methods=["post"], url_path="publish-test")
-    def publish_test(self, request):
+    async def publish_test(self, request):
         """
-        Publish test message via wrapper.
+        Publish test message via wrapper (ASYNC).
 
         Proxies request to Centrifugo wrapper with ACK tracking support.
         """
         try:
             req_data = PublishTestRequest(**request.data)
 
-            # Call wrapper API
-            result = asyncio.run(
-                self._publish_to_wrapper(
-                    channel=req_data.channel,
-                    data=req_data.data,
-                    wait_for_ack=req_data.wait_for_ack,
-                    ack_timeout=req_data.ack_timeout,
-                )
+            # Call wrapper API (ASYNC - no asyncio.run()!)
+            result = await self._publish_to_wrapper(
+                channel=req_data.channel,
+                data=req_data.data,
+                wait_for_ack=req_data.wait_for_ack,
+                ack_timeout=req_data.ack_timeout,
             )
 
             response = PublishTestResponse(
@@ -180,20 +177,18 @@ class CentrifugoTestingAPIViewSet(AdminAPIMixin, viewsets.ViewSet):
         },
     )
     @action(detail=False, methods=["post"], url_path="send-ack")
-    def send_ack(self, request):
+    async def send_ack(self, request):
         """
-        Send manual ACK for message.
+        Send manual ACK for message (ASYNC).
 
         Proxies ACK to wrapper for testing ACK flow.
         """
         try:
             req_data = ManualAckRequest(**request.data)
 
-            # Send ACK to wrapper
-            result = asyncio.run(
-                self._send_ack_to_wrapper(
-                    message_id=req_data.message_id, client_id=req_data.client_id
-                )
+            # Send ACK to wrapper (ASYNC - no asyncio.run()!)
+            result = await self._send_ack_to_wrapper(
+                message_id=req_data.message_id, client_id=req_data.client_id
             )
 
             response = ManualAckResponse(
@@ -334,9 +329,9 @@ class CentrifugoTestingAPIViewSet(AdminAPIMixin, viewsets.ViewSet):
         },
     )
     @action(detail=False, methods=["post"], url_path="publish-with-logging")
-    def publish_with_logging(self, request):
+    async def publish_with_logging(self, request):
         """
-        Publish message using CentrifugoClient with database logging.
+        Publish message using CentrifugoClient with database logging (ASYNC).
 
         This endpoint uses the production CentrifugoClient which logs all
         publishes to the database (CentrifugoLog model).
@@ -347,25 +342,24 @@ class CentrifugoTestingAPIViewSet(AdminAPIMixin, viewsets.ViewSet):
             # Use CentrifugoClient for publishing
             client = CentrifugoClient()
 
-            # Publish message
-            result = asyncio.run(
-                client.publish_with_ack(
+            # Publish message (ASYNC - no asyncio.run()!)
+            if req_data.wait_for_ack:
+                result = await client.publish_with_ack(
                     channel=req_data.channel,
                     data=req_data.data,
-                    ack_timeout=req_data.ack_timeout if req_data.wait_for_ack else None,
+                    ack_timeout=req_data.ack_timeout,
                     user=request.user if request.user.is_authenticated else None,
                     caller_ip=request.META.get("REMOTE_ADDR"),
                     user_agent=request.META.get("HTTP_USER_AGENT"),
                 )
-                if req_data.wait_for_ack
-                else client.publish(
+            else:
+                result = await client.publish(
                     channel=req_data.channel,
                     data=req_data.data,
                     user=request.user if request.user.is_authenticated else None,
                     caller_ip=request.META.get("REMOTE_ADDR"),
                     user_agent=request.META.get("HTTP_USER_AGENT"),
                 )
-            )
 
             # Convert PublishResponse to dict
             response_data = {
@@ -386,17 +380,17 @@ class CentrifugoTestingAPIViewSet(AdminAPIMixin, viewsets.ViewSet):
                 status=status.HTTP_500_INTERNAL_SERVER_ERROR,
             )
 
-    def __del__(self):
-        """Cleanup HTTP client on deletion."""
+    async def cleanup(self):
+        """
+        Explicit async cleanup method for HTTP client.
+
+        Note: Django handles ViewSet lifecycle automatically.
+        This method is provided for explicit cleanup if needed,
+        but httpx.AsyncClient will be garbage collected normally.
+        """
         if self._http_client:
-            try:
-                loop = asyncio.get_event_loop()
-                if loop.is_running():
-                    loop.create_task(self._http_client.aclose())
-                else:
-                    loop.run_until_complete(self._http_client.aclose())
-            except Exception:
-                pass
+            await self._http_client.aclose()
+            self._http_client = None
 
 
 __all__ = ["CentrifugoTestingAPIViewSet"]

django_cfg/apps/integrations/centrifugo/views/wrapper.py

@@ -5,12 +5,12 @@ Provides /api/publish endpoint that acts as a proxy to Centrifugo
 with ACK tracking and database logging.
 """
 
-import asyncio
 import time
 import uuid
 from typing import Any, Dict
 
 import httpx
+from django.db import transaction
 from django.http import JsonResponse
 from django.utils.decorators import method_decorator
 from django.views import View
@@ -55,15 +55,19 @@ class PublishResponse(BaseModel):
 
 
 @method_decorator(csrf_exempt, name='dispatch')
+@method_decorator(transaction.non_atomic_requests, name='dispatch')
 class PublishWrapperView(View):
     """
-    Centrifugo publish wrapper endpoint.
+    Centrifugo publish wrapper endpoint (ASYNC).
 
     Provides /api/publish endpoint that:
     - Accepts publish requests from CentrifugoClient
     - Logs to database (CentrifugoLog)
     - Proxies to Centrifugo HTTP API
     - Returns publish result with ACK tracking
+
+    NOTE: This is an async view for proper async/await handling.
+    Using asyncio.run() in sync views causes event loop conflicts.
     """
 
     def __init__(self, *args, **kwargs):
@@ -181,9 +185,9 @@ class PublishWrapperView(View):
 
             raise
 
-    def post(self, request):
+    async def post(self, request):
         """
-        Handle POST /api/publish request.
+        Handle POST /api/publish request (ASYNC).
 
         Request body:
             {
@@ -213,15 +217,13 @@ class PublishWrapperView(View):
             # Generate message ID if not provided
             message_id = req_data.message_id or str(uuid.uuid4())
 
-            # Publish to Centrifugo
-            result = asyncio.run(
-                self._publish_to_centrifugo(
-                    channel=req_data.channel,
-                    data=req_data.data,
-                    wait_for_ack=req_data.wait_for_ack,
-                    ack_timeout=req_data.ack_timeout,
-                    message_id=message_id,
-                )
+            # Publish to Centrifugo (ASYNC - no asyncio.run()!)
+            result = await self._publish_to_centrifugo(
+                channel=req_data.channel,
+                data=req_data.data,
+                wait_for_ack=req_data.wait_for_ack,
+                ack_timeout=req_data.ack_timeout,
+                message_id=message_id,
             )
 
             response = PublishResponse(**result)
@@ -241,17 +243,17 @@ class PublishWrapperView(View):
                 status=500,
             )
 
-    def __del__(self):
-        """Cleanup HTTP client on deletion."""
+    async def cleanup(self):
+        """
+        Explicit async cleanup method for HTTP client.
+
+        Note: Django handles View lifecycle automatically.
+        This method is provided for explicit cleanup if needed,
+        but httpx.AsyncClient will be garbage collected normally.
+        """
         if self._http_client:
-            try:
-                loop = asyncio.get_event_loop()
-                if loop.is_running():
-                    loop.create_task(self._http_client.aclose())
-                else:
-                    loop.run_until_complete(self._http_client.aclose())
-            except Exception:
-                pass
+            await self._http_client.aclose()
+            self._http_client = None
 
 
 __all__ = ["PublishWrapperView"]

django_cfg/apps/integrations/grpc/auth/api_key_auth.py

@@ -170,10 +170,11 @@ class ApiKeyAuthInterceptor(grpc.aio.ServerInterceptor):
             logger.debug("API key matches Django SECRET_KEY")
             # For SECRET_KEY, return first superuser or None (no api_key instance)
             try:
-                # Wrap Django ORM in asyncio.to_thread()
-                superuser = await asyncio.to_thread(
-                    lambda: User.objects.filter(is_superuser=True, is_active=True).first()
-                )
+                # Django 5.2: Native async ORM
+                superuser = await User.objects.filter(
+                    is_superuser=True, is_active=True
+                ).afirst()
+
                 if superuser:
                     return superuser, None
                 else:
@@ -187,14 +188,14 @@ class ApiKeyAuthInterceptor(grpc.aio.ServerInterceptor):
         try:
             from django_cfg.apps.integrations.grpc.models import GrpcApiKey
 
-            # Wrap Django ORM in asyncio.to_thread()
-            api_key_obj = await asyncio.to_thread(
-                lambda: GrpcApiKey.objects.filter(key=api_key, is_active=True).first()
-            )
+            # Django 5.2: Native async ORM
+            api_key_obj = await GrpcApiKey.objects.filter(
+                key=api_key, is_active=True
+            ).afirst()
 
             if api_key_obj and api_key_obj.is_valid:
-                # Update usage tracking (also wrapped in to_thread)
-                await asyncio.to_thread(api_key_obj.mark_used)
+                # Update usage tracking (async method call)
+                await api_key_obj.amark_used()
                 logger.debug(f"Valid API key for user {api_key_obj.user.id} ({api_key_obj.user.username})")
                 return api_key_obj.user, api_key_obj
             else:

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

@@ -50,7 +50,7 @@ class Command(AdminCommand):
 
     def handle(self, *args, **options):
         from django_cfg.apps.integrations.grpc.utils.proto_gen import generate_proto_for_app
-        from django_cfg.apps.integrations.grpc.services.config_helper import get_grpc_config
+        from django_cfg.apps.integrations.grpc.services.management.config_helper import get_grpc_config
 
         # Get gRPC config
         grpc_config = get_grpc_config()

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,10 @@ 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
+                    server_status.mark_stopping()
                 except Exception as e:
                     self.logger.warning(f"Could not mark server as stopping: {e}")
 
@@ -807,12 +793,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}")