django-cfg 1.5.20__py3-none-any.whl → 1.5.31__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.31"
 __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

@@ -8,6 +8,7 @@ Mirrors RPCLogger patterns from legacy WebSocket solution for easy migration.
 import time
 from typing import Any, Optional
 
+from django.utils import timezone
 from django_cfg.modules.django_logging import get_logger
 
 logger = get_logger("centrifugo")
@@ -87,11 +88,11 @@ class CentrifugoLogger:
 
         logger.info(f"✅ Creating CentrifugoLog entry for {message_id} (async)")
         try:
-            from asgiref.sync import sync_to_async
             from ..models import CentrifugoLog
 
-            # Wrap ORM call in sync_to_async
-            log_entry = await sync_to_async(CentrifugoLog.objects.create)(
+            # ✅ Use Django 5.2+ async ORM instead of sync_to_async
+            # This prevents connection leaks from sync_to_async threads
+            log_entry = await CentrifugoLog.objects.acreate(
                 message_id=message_id,
                 channel=channel,
                 data=data,
@@ -234,14 +235,17 @@ class CentrifugoLogger:
             return
 
         try:
-            from asgiref.sync import sync_to_async
             from ..models import CentrifugoLog
 
-            await sync_to_async(CentrifugoLog.objects.mark_success)(
-                log_instance=log_entry,
-                acks_received=acks_received,
-                duration_ms=duration_ms,
-            )
+            # ✅ Use Django 5.2+ async ORM instead of sync_to_async
+            log_entry.status = CentrifugoLog.StatusChoices.SUCCESS
+            log_entry.acks_received = acks_received
+            log_entry.completed_at = timezone.now()
+
+            if duration_ms is not None:
+                log_entry.duration_ms = duration_ms
+
+            await log_entry.asave(update_fields=["status", "acks_received", "completed_at", "duration_ms"])
 
             logger.info(
                 f"Centrifugo publish successful: {log_entry.message_id}",
@@ -400,6 +404,64 @@ 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 ..models import CentrifugoLog
+
+            # ✅ Use Django 5.2+ async ORM instead of sync_to_async
+            log_entry.status = CentrifugoLog.StatusChoices.FAILED
+            log_entry.error_code = error_code
+            log_entry.error_message = error_message
+            log_entry.completed_at = timezone.now()
+
+            if duration_ms is not None:
+                log_entry.duration_ms = duration_ms
+
+            await log_entry.asave(
+                update_fields=[
+                    "status",
+                    "error_code",
+                    "error_message",
+                    "completed_at",
+                    "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,
@@ -418,13 +480,27 @@ class CentrifugoLogger:
             return
 
         try:
-            from asgiref.sync import sync_to_async
             from ..models import CentrifugoLog
 
-            await sync_to_async(CentrifugoLog.objects.mark_timeout)(
-                log_instance=log_entry,
-                acks_received=acks_received,
-                duration_ms=duration_ms,
+            # ✅ Use Django 5.2+ async ORM instead of sync_to_async
+            log_entry.status = CentrifugoLog.StatusChoices.TIMEOUT
+            log_entry.acks_received = acks_received
+            log_entry.error_code = "timeout"
+            log_entry.error_message = f"Timeout after {log_entry.ack_timeout}s"
+            log_entry.completed_at = timezone.now()
+
+            if duration_ms is not None:
+                log_entry.duration_ms = duration_ms
+
+            await log_entry.asave(
+                update_fields=[
+                    "status",
+                    "acks_received",
+                    "error_code",
+                    "error_message",
+                    "completed_at",
+                    "duration_ms",
+                ]
             )
 
             logger.warning(

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
@@ -13,6 +12,7 @@ from typing import Any, Dict
 import httpx
 import jwt
 from django.conf import settings
+from django.utils import timezone
 from django_cfg.modules.django_logging import get_logger
 from drf_spectacular.utils import extend_schema
 from pydantic import BaseModel, Field
@@ -127,23 +127,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 +178,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(
@@ -289,14 +285,23 @@ class CentrifugoTestingAPIViewSet(AdminAPIMixin, viewsets.ViewSet):
 
             # Mark as failed
             if log_entry:
-                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=type(e).__name__,
-                    error_message=str(e),
-                    duration_ms=duration_ms,
+                # ✅ Use Django 5.2+ async ORM instead of sync_to_async
+                log_entry.status = CentrifugoLog.StatusChoices.FAILED
+                log_entry.error_code = type(e).__name__
+                log_entry.error_message = str(e)
+                log_entry.completed_at = timezone.now()
+                log_entry.duration_ms = duration_ms
+
+                await log_entry.asave(
+                    update_fields=[
+                        "status",
+                        "error_code",
+                        "error_message",
+                        "completed_at",
+                        "duration_ms",
+                    ]
                 )
 
             raise
@@ -334,9 +339,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 +352,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 +390,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,13 +5,14 @@ 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 import timezone
 from django.utils.decorators import method_decorator
 from django.views import View
 from django.views.decorators.csrf import csrf_exempt
@@ -55,15 +56,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):
@@ -169,21 +174,30 @@ class PublishWrapperView(View):
 
             # Mark as failed
             if log_entry:
-                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=type(e).__name__,
-                    error_message=str(e),
-                    duration_ms=duration_ms,
+                # ✅ Use Django 5.2+ async ORM instead of sync_to_async
+                log_entry.status = CentrifugoLog.StatusChoices.FAILED
+                log_entry.error_code = type(e).__name__
+                log_entry.error_message = str(e)
+                log_entry.completed_at = timezone.now()
+                log_entry.duration_ms = duration_ms
+
+                await log_entry.asave(
+                    update_fields=[
+                        "status",
+                        "error_code",
+                        "error_message",
+                        "completed_at",
+                        "duration_ms",
+                    ]
                 )
 
             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 +227,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 +253,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()