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

django_cfg/apps/integrations/grpc/interceptors/metrics.py

@@ -12,6 +12,7 @@ from collections import defaultdict
 from typing import Callable
 
 import grpc
+import grpc.aio
 
 logger = logging.getLogger(__name__)
 
@@ -135,9 +136,9 @@ def reset_metrics():
     _metrics.reset()
 
 
-class MetricsInterceptor(grpc.ServerInterceptor):
+class MetricsInterceptor(grpc.aio.ServerInterceptor):
     """
-    gRPC interceptor for metrics collection.
+    gRPC interceptor for metrics collection (async).
 
     Features:
     - Tracks request counts
@@ -170,13 +171,13 @@ class MetricsInterceptor(grpc.ServerInterceptor):
         """Initialize metrics interceptor."""
         self.collector = _metrics
 
-    def intercept_service(
+    async def intercept_service(
         self,
         continuation: Callable,
         handler_call_details: grpc.HandlerCallDetails,
     ) -> grpc.RpcMethodHandler:
         """
-        Intercept gRPC service call for metrics collection.
+        Intercept gRPC service call for metrics collection (async).
 
         Args:
             continuation: Function to invoke the next interceptor or handler
@@ -190,8 +191,8 @@ class MetricsInterceptor(grpc.ServerInterceptor):
         # Record request
         self.collector.record_request(method_name)
 
-        # Get handler and wrap it
-        handler = continuation(handler_call_details)
+        # Get handler and wrap it (await for async)
+        handler = await continuation(handler_call_details)
 
         if handler is None:
             return None
@@ -215,10 +216,10 @@ class MetricsInterceptor(grpc.ServerInterceptor):
             Wrapped RPC method handler
         """
         def wrap_unary_unary(behavior):
-            def wrapper(request, context):
+            async def wrapper(request, context):
                 start_time = time.time()
                 try:
-                    response = behavior(request, context)
+                    response = await behavior(request, context)
                     duration_ms = (time.time() - start_time) * 1000
                     self.collector.record_response_time(method_name, duration_ms)
                     return response
@@ -230,10 +231,10 @@ class MetricsInterceptor(grpc.ServerInterceptor):
             return wrapper
 
         def wrap_unary_stream(behavior):
-            def wrapper(request, context):
+            async def wrapper(request, context):
                 start_time = time.time()
                 try:
-                    for response in behavior(request, context):
+                    async for response in behavior(request, context):
                         yield response
                     duration_ms = (time.time() - start_time) * 1000
                     self.collector.record_response_time(method_name, duration_ms)
@@ -245,10 +246,10 @@ class MetricsInterceptor(grpc.ServerInterceptor):
             return wrapper
 
         def wrap_stream_unary(behavior):
-            def wrapper(request_iterator, context):
+            async def wrapper(request_iterator, context):
                 start_time = time.time()
                 try:
-                    response = behavior(request_iterator, context)
+                    response = await behavior(request_iterator, context)
                     duration_ms = (time.time() - start_time) * 1000
                     self.collector.record_response_time(method_name, duration_ms)
                     return response
@@ -260,10 +261,10 @@ class MetricsInterceptor(grpc.ServerInterceptor):
             return wrapper
 
         def wrap_stream_stream(behavior):
-            def wrapper(request_iterator, context):
+            async def wrapper(request_iterator, context):
                 start_time = time.time()
                 try:
-                    for response in behavior(request_iterator, context):
+                    async for response in behavior(request_iterator, context):
                         yield response
                     duration_ms = (time.time() - start_time) * 1000
                     self.collector.record_response_time(method_name, duration_ms)

django_cfg/apps/integrations/grpc/interceptors/request_logger.py

@@ -6,19 +6,21 @@ Automatically logs all gRPC requests to the database for monitoring.
 
 from __future__ import annotations
 
+import asyncio
 import logging
 import time
 import uuid
 from typing import Callable
 
 import grpc
+import grpc.aio
 
 logger = logging.getLogger(__name__)
 
 
-class RequestLoggerInterceptor(grpc.ServerInterceptor):
+class RequestLoggerInterceptor(grpc.aio.ServerInterceptor):
     """
-    gRPC interceptor for request logging to database.
+    gRPC interceptor for request logging to database (async).
 
     Features:
     - Logs all requests to GRPCRequestLog model
@@ -53,13 +55,13 @@ class RequestLoggerInterceptor(grpc.ServerInterceptor):
         self.log_request_data = log_request_data
         self.log_response_data = log_response_data
 
-    def intercept_service(
+    async def intercept_service(
         self,
         continuation: Callable,
         handler_call_details: grpc.HandlerCallDetails,
     ) -> grpc.RpcMethodHandler:
         """
-        Intercept gRPC service call for logging.
+        Intercept gRPC service call for logging (async).
 
         Args:
             continuation: Function to invoke the next interceptor or handler
@@ -80,8 +82,8 @@ class RequestLoggerInterceptor(grpc.ServerInterceptor):
         peer = metadata_dict.get("peer", "unknown")
         user_agent = metadata_dict.get("user-agent", None)
 
-        # Get handler and wrap it
-        handler = continuation(handler_call_details)
+        # Get handler and wrap it (await for async)
+        handler = await continuation(handler_call_details)
 
         if handler is None:
             logger.warning(f"[gRPC Logger] No handler found for {full_method}")
@@ -124,11 +126,11 @@ class RequestLoggerInterceptor(grpc.ServerInterceptor):
             Wrapped RPC method handler
         """
         def wrap_unary_unary(behavior):
-            def wrapper(request, context):
+            async def wrapper(request, context):
                 start_time = time.time()
 
-                # Create log entry
-                log_entry = self._create_log_entry(
+                # Create log entry (async)
+                log_entry = await self._create_log_entry_async(
                     request_id=request_id,
                     service_name=service_name,
                     method_name=method_name,
@@ -140,11 +142,11 @@ class RequestLoggerInterceptor(grpc.ServerInterceptor):
                 )
 
                 try:
-                    response = behavior(request, context)
+                    response = await behavior(request, context)
                     duration_ms = int((time.time() - start_time) * 1000)
 
-                    # Mark as successful
-                    self._mark_success(
+                    # Mark as successful (async)
+                    await self._mark_success_async(
                         log_entry,
                         duration_ms=duration_ms,
                         response=response if self.log_response_data else None,
@@ -154,8 +156,8 @@ class RequestLoggerInterceptor(grpc.ServerInterceptor):
                 except Exception as e:
                     duration_ms = int((time.time() - start_time) * 1000)
 
-                    # Mark as error
-                    self._mark_error(
+                    # Mark as error (async)
+                    await self._mark_error_async(
                         log_entry,
                         error=e,
                         context=context,
@@ -167,11 +169,11 @@ class RequestLoggerInterceptor(grpc.ServerInterceptor):
             return wrapper
 
         def wrap_unary_stream(behavior):
-            def wrapper(request, context):
+            async def wrapper(request, context):
                 start_time = time.time()
 
-                # Create log entry
-                log_entry = self._create_log_entry(
+                # Create log entry (async)
+                log_entry = await self._create_log_entry_async(
                     request_id=request_id,
                     service_name=service_name,
                     method_name=method_name,
@@ -184,14 +186,14 @@ class RequestLoggerInterceptor(grpc.ServerInterceptor):
 
                 try:
                     response_count = 0
-                    for response in behavior(request, context):
+                    async for response in behavior(request, context):
                         response_count += 1
                         yield response
 
                     duration_ms = int((time.time() - start_time) * 1000)
 
-                    # Mark as successful
-                    self._mark_success(
+                    # Mark as successful (async)
+                    await self._mark_success_async(
                         log_entry,
                         duration_ms=duration_ms,
                         response_data={"message_count": response_count} if not self.log_response_data else None,
@@ -200,8 +202,8 @@ class RequestLoggerInterceptor(grpc.ServerInterceptor):
                 except Exception as e:
                     duration_ms = int((time.time() - start_time) * 1000)
 
-                    # Mark as error
-                    self._mark_error(
+                    # Mark as error (async)
+                    await self._mark_error_async(
                         log_entry,
                         error=e,
                         context=context,
@@ -213,11 +215,11 @@ class RequestLoggerInterceptor(grpc.ServerInterceptor):
             return wrapper
 
         def wrap_stream_unary(behavior):
-            def wrapper(request_iterator, context):
+            async def wrapper(request_iterator, context):
                 start_time = time.time()
 
-                # Create log entry
-                log_entry = self._create_log_entry(
+                # Create log entry (async)
+                log_entry = await self._create_log_entry_async(
                     request_id=request_id,
                     service_name=service_name,
                     method_name=method_name,
@@ -228,19 +230,23 @@ class RequestLoggerInterceptor(grpc.ServerInterceptor):
                 )
 
                 try:
-                    # Count requests
+                    # Count requests (async for)
                     requests = []
                     request_count = 0
-                    for req in request_iterator:
+                    async for req in request_iterator:
                         request_count += 1
                         requests.append(req)
 
-                    # Process
-                    response = behavior(iter(requests), context)
+                    # Process (create async generator)
+                    async def async_iter():
+                        for r in requests:
+                            yield r
+
+                    response = await behavior(async_iter(), context)
                     duration_ms = int((time.time() - start_time) * 1000)
 
-                    # Mark as successful
-                    self._mark_success(
+                    # Mark as successful (async)
+                    await self._mark_success_async(
                         log_entry,
                         duration_ms=duration_ms,
                         request_data={"message_count": request_count} if not self.log_request_data else None,
@@ -251,8 +257,8 @@ class RequestLoggerInterceptor(grpc.ServerInterceptor):
                 except Exception as e:
                     duration_ms = int((time.time() - start_time) * 1000)
 
-                    # Mark as error
-                    self._mark_error(
+                    # Mark as error (async)
+                    await self._mark_error_async(
                         log_entry,
                         error=e,
                         context=context,
@@ -264,11 +270,11 @@ class RequestLoggerInterceptor(grpc.ServerInterceptor):
             return wrapper
 
         def wrap_stream_stream(behavior):
-            def wrapper(request_iterator, context):
+            async def wrapper(request_iterator, context):
                 start_time = time.time()
 
-                # Create log entry
-                log_entry = self._create_log_entry(
+                # Create log entry (async)
+                log_entry = await self._create_log_entry_async(
                     request_id=request_id,
                     service_name=service_name,
                     method_name=method_name,
@@ -279,23 +285,27 @@ class RequestLoggerInterceptor(grpc.ServerInterceptor):
                 )
 
                 try:
-                    # Count requests
+                    # Count requests (async for)
                     requests = []
                     request_count = 0
-                    for req in request_iterator:
+                    async for req in request_iterator:
                         request_count += 1
                         requests.append(req)
 
-                    # Process and count responses
+                    # Process and count responses (async for)
+                    async def async_iter():
+                        for r in requests:
+                            yield r
+
                     response_count = 0
-                    for response in behavior(iter(requests), context):
+                    async for response in behavior(async_iter(), context):
                         response_count += 1
                         yield response
 
                     duration_ms = int((time.time() - start_time) * 1000)
 
-                    # Mark as successful
-                    self._mark_success(
+                    # Mark as successful (async)
+                    await self._mark_success_async(
                         log_entry,
                         duration_ms=duration_ms,
                         response_data={"request_count": request_count, "response_count": response_count} if not self.log_response_data else None,
@@ -304,8 +314,8 @@ class RequestLoggerInterceptor(grpc.ServerInterceptor):
                 except Exception as e:
                     duration_ms = int((time.time() - start_time) * 1000)
 
-                    # Mark as error
-                    self._mark_error(
+                    # Mark as error (async)
+                    await self._mark_error_async(
                         log_entry,
                         error=e,
                         context=context,
@@ -344,7 +354,7 @@ class RequestLoggerInterceptor(grpc.ServerInterceptor):
         else:
             return handler
 
-    def _create_log_entry(
+    async def _create_log_entry_async(
         self,
         request_id: str,
         service_name: str,
@@ -352,27 +362,33 @@ class RequestLoggerInterceptor(grpc.ServerInterceptor):
         full_method: str,
         peer: str,
         user_agent: str,
-        context: grpc.ServicerContext,
+        context: grpc.aio.ServicerContext,
         request=None,
     ):
-        """Create initial log entry in database."""
+        """Create initial log entry in database (async)."""
         try:
             from ..models import GRPCRequestLog
+            from ..auth import get_current_grpc_user, get_current_grpc_api_key
 
-            # Get user from context (set by JWTAuthInterceptor)
-            user = getattr(context, "user", None)
+            # Get user and api_key from contextvars (set by ApiKeyAuthInterceptor)
+            user = get_current_grpc_user()
+            api_key = get_current_grpc_api_key()
             is_authenticated = user is not None
 
+            logger.info(f"[RequestLogger] Got contextvar api_key = {api_key} (user={user}, authenticated={is_authenticated})")
+
             # Extract client IP from peer
             client_ip = self._extract_ip_from_peer(peer)
 
-            # Create log entry
-            log_entry = GRPCRequestLog.objects.create(
+            # Create log entry (wrap Django ORM in asyncio.to_thread)
+            log_entry = await asyncio.to_thread(
+                GRPCRequestLog.objects.create,
                 request_id=request_id,
                 service_name=service_name,
                 method_name=method_name,
                 full_method=full_method,
                 user=user if is_authenticated else None,
+                api_key=api_key,
                 is_authenticated=is_authenticated,
                 client_ip=client_ip,
                 user_agent=user_agent,
@@ -387,7 +403,7 @@ class RequestLoggerInterceptor(grpc.ServerInterceptor):
             logger.error(f"Failed to create log entry: {e}", exc_info=True)
             return None
 
-    def _mark_success(
+    async def _mark_success_async(
         self,
         log_entry,
         duration_ms: int,
@@ -395,7 +411,7 @@ class RequestLoggerInterceptor(grpc.ServerInterceptor):
         request_data: dict = None,
         response_data: dict = None,
     ):
-        """Mark log entry as successful."""
+        """Mark log entry as successful (async)."""
         if log_entry is None:
             return
 
@@ -406,7 +422,9 @@ class RequestLoggerInterceptor(grpc.ServerInterceptor):
             if response:
                 response_data = self._serialize_message(response)
 
-            GRPCRequestLog.objects.mark_success(
+            # Wrap Django ORM in asyncio.to_thread
+            await asyncio.to_thread(
+                GRPCRequestLog.objects.mark_success,
                 log_entry,
                 duration_ms=duration_ms,
                 response_data=response_data,
@@ -415,14 +433,14 @@ class RequestLoggerInterceptor(grpc.ServerInterceptor):
         except Exception as e:
             logger.error(f"Failed to mark success: {e}", exc_info=True)
 
-    def _mark_error(
+    async def _mark_error_async(
         self,
         log_entry,
         error: Exception,
-        context: grpc.ServicerContext,
+        context: grpc.aio.ServicerContext,
         duration_ms: int,
     ):
-        """Mark log entry as error."""
+        """Mark log entry as error (async)."""
         if log_entry is None:
             return
 
@@ -432,7 +450,9 @@ class RequestLoggerInterceptor(grpc.ServerInterceptor):
             # Get gRPC status code
             grpc_code = self._get_grpc_code(error, context)
 
-            GRPCRequestLog.objects.mark_error(
+            # Wrap Django ORM in asyncio.to_thread
+            await asyncio.to_thread(
+                GRPCRequestLog.objects.mark_error,
                 log_entry,
                 grpc_status_code=grpc_code,
                 error_message=str(error),
@@ -485,7 +505,7 @@ class RequestLoggerInterceptor(grpc.ServerInterceptor):
             pass
         return None
 
-    def _get_grpc_code(self, error: Exception, context: grpc.ServicerContext) -> str:
+    def _get_grpc_code(self, error: Exception, context: grpc.aio.ServicerContext) -> str:
         """Get gRPC status code from error."""
         try:
             # Check if error is a gRPC error

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

@@ -0,0 +1,105 @@
+"""
+Django management command to compile .proto files to Python.
+
+Usage:
+    # Compile single proto file
+    python manage.py compile_proto path/to/file.proto
+
+    # Compile with custom output directory
+    python manage.py compile_proto path/to/file.proto --output-dir generated/
+
+    # Auto-fix imports (change 'import X' to 'from . import X')
+    python manage.py compile_proto path/to/file.proto --fix-imports
+
+    # Compile all proto files in a directory
+    python manage.py compile_proto path/to/protos/ --recursive
+"""
+
+import logging
+from pathlib import Path
+
+from django.core.management.base import BaseCommand, CommandError
+
+from django_cfg.apps.integrations.grpc.management.proto.compiler import ProtoCompiler
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    help = "Compile .proto files to Python using grpc_tools.protoc"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "proto_path",
+            type=str,
+            help="Path to .proto file or directory containing .proto files",
+        )
+        parser.add_argument(
+            "--output-dir",
+            type=str,
+            default=None,
+            help="Output directory for generated files (default: same as proto file)",
+        )
+        parser.add_argument(
+            "--proto-path",
+            type=str,
+            default=None,
+            help="Additional proto import path (passed to protoc -I flag)",
+        )
+        parser.add_argument(
+            "--fix-imports",
+            action="store_true",
+            default=True,
+            help="Fix imports in generated _grpc.py files (default: True)",
+        )
+        parser.add_argument(
+            "--no-fix-imports",
+            action="store_false",
+            dest="fix_imports",
+            help="Disable import fixing",
+        )
+        parser.add_argument(
+            "--recursive",
+            action="store_true",
+            help="Recursively compile all .proto files in directory",
+        )
+
+    def handle(self, *args, **options):
+        proto_path = Path(options["proto_path"])
+        output_dir = Path(options["output_dir"]) if options["output_dir"] else None
+        proto_import_path = Path(options["proto_path"]) if options.get("proto_path") else None
+        fix_imports = options["fix_imports"]
+        recursive = options["recursive"]
+
+        if not proto_path.exists():
+            raise CommandError(f"Path does not exist: {proto_path}")
+
+        # Create compiler
+        compiler = ProtoCompiler(
+            output_dir=output_dir,
+            proto_import_path=proto_import_path,
+            fix_imports=fix_imports,
+            verbose=True,
+        )
+
+        self.stdout.write("")
+
+        # Compile proto file(s)
+        if proto_path.is_file():
+            success = compiler.compile_file(proto_path)
+            if not success:
+                raise CommandError(f"Failed to compile {proto_path}")
+        else:
+            success_count, failure_count = compiler.compile_directory(
+                proto_path,
+                recursive=recursive,
+            )
+
+            if failure_count > 0:
+                raise CommandError(
+                    f"Failed to compile {failure_count} proto file(s) "
+                    f"({success_count} succeeded)"
+                )
+
+        self.stdout.write("")
+        self.stdout.write(self.style.SUCCESS("🎉 Done! All proto files compiled successfully."))