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

django_cfg/middleware/pagination.py

@@ -190,62 +190,62 @@ class NoPagination(PageNumberPagination):
         return Response(data)
 
 
-class CursorPaginationEnhanced(PageNumberPagination):
-    """
-    Enhanced cursor-based pagination for large datasets.
+# class CursorPaginationEnhanced(PageNumberPagination):
+#     """
+#     Enhanced cursor-based pagination for large datasets.
     
-    Better performance for large datasets but doesn't support jumping to arbitrary pages.
-    """
-    page_size = 100
-    page_size_query_param = 'page_size'
-    max_page_size = 1000
-    cursor_query_param = 'cursor'
-    ordering = '-created_at'  # Default ordering, should be overridden
+#     Better performance for large datasets but doesn't support jumping to arbitrary pages.
+#     """
+#     page_size = 100
+#     page_size_query_param = 'page_size'
+#     max_page_size = 1000
+#     cursor_query_param = 'cursor'
+#     ordering = '-created_at'  # Default ordering, should be overridden
 
-    def get_paginated_response(self, data):
-        """
-        Return cursor-paginated response with enhanced format.
-        """
-        return Response({
-            'next': self.get_next_link(),
-            'previous': self.get_previous_link(),
-            'page_size': self.page_size,
-            'results': data,
-        })
+#     def get_paginated_response(self, data):
+#         """
+#         Return cursor-paginated response with enhanced format.
+#         """
+#         return Response({
+#             'next': self.get_next_link(),
+#             'previous': self.get_previous_link(),
+#             'page_size': self.page_size,
+#             'results': data,
+#         })
 
-    def get_paginated_response_schema(self, schema):
-        """
-        Return the OpenAPI schema for cursor-paginated responses.
-        """
-        return {
-            'type': 'object',
-            'required': ['results'],
-            'properties': {
-                'next': {
-                    'type': 'string',
-                    'nullable': True,
-                    'format': 'uri',
-                    'description': 'URL to next page of results',
-                    'example': 'http://api.example.org/accounts/?cursor=cD0yMDIzLTEyLTE1KzAyJTNBMDA%3D'
-                },
-                'previous': {
-                    'type': 'string',
-                    'nullable': True,
-                    'format': 'uri',
-                    'description': 'URL to previous page of results',
-                    'example': 'http://api.example.org/accounts/?cursor=bD0yMDIzLTEyLTEzKzAyJTNBMDA%3D'
-                },
-                'page_size': {
-                    'type': 'integer',
-                    'description': 'Number of items per page',
-                    'example': 100
-                },
-                'results': {
-                    **schema,
-                    'description': 'Array of items for current page'
-                },
-            },
-        }
+#     def get_paginated_response_schema(self, schema):
+#         """
+#         Return the OpenAPI schema for cursor-paginated responses.
+#         """
+#         return {
+#             'type': 'object',
+#             'required': ['results'],
+#             'properties': {
+#                 'next': {
+#                     'type': 'string',
+#                     'nullable': True,
+#                     'format': 'uri',
+#                     'description': 'URL to next page of results',
+#                     'example': 'http://api.example.org/accounts/?cursor=cD0yMDIzLTEyLTE1KzAyJTNBMDA%3D'
+#                 },
+#                 'previous': {
+#                     'type': 'string',
+#                     'nullable': True,
+#                     'format': 'uri',
+#                     'description': 'URL to previous page of results',
+#                     'example': 'http://api.example.org/accounts/?cursor=bD0yMDIzLTEyLTEzKzAyJTNBMDA%3D'
+#                 },
+#                 'page_size': {
+#                     'type': 'integer',
+#                     'description': 'Number of items per page',
+#                     'example': 100
+#                 },
+#                 'results': {
+#                     **schema,
+#                     'description': 'Array of items for current page'
+#                 },
+#             },
+#         }
 
 
 # Export all pagination classes
@@ -254,5 +254,4 @@ __all__ = [
     'LargePagination',
     'SmallPagination',
     'NoPagination',
-    'CursorPaginationEnhanced',
 ]

django_cfg/models/api/grpc/__init__.py

@@ -1,33 +1,35 @@
 """
 gRPC configuration models.
 
-Type-safe Pydantic v2 models for gRPC server, authentication, and proto generation.
+Type-safe Pydantic v2 models for gRPC integration.
 
 Requires: pip install django-cfg[grpc]
 
 Example:
-    >>> from django_cfg.models.api.grpc import GRPCConfig, GRPCServerConfig
+    Flat API (recommended - no nested config imports needed):
+    >>> from django_cfg import GRPCConfig
     >>> config = GRPCConfig(
     ...     enabled=True,
-    ...     server=GRPCServerConfig(port=50051)
+    ...     enabled_apps=["crypto"],
+    ...     port=50051,
+    ...     package_prefix="api",
+    ... )
+
+    Advanced with nested configs (optional):
+    >>> from django_cfg.models.api.grpc.config import GRPCServerConfig
+    >>> config = GRPCConfig(
+    ...     enabled=True,
+    ...     server=GRPCServerConfig(max_workers=50, compression="gzip")
     ... )
 """
 
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from .config import (
-        GRPCAuthConfig,
-        GRPCConfig,
-        GRPCProtoConfig,
-        GRPCServerConfig,
-    )
+    from .config import GRPCConfig
 
 __all__ = [
     "GRPCConfig",
-    "GRPCServerConfig",
-    "GRPCAuthConfig",
-    "GRPCProtoConfig",
 ]
 
 
@@ -35,18 +37,10 @@ def __getattr__(name: str):
     """Lazy import with helpful error message."""
     if name in __all__:
         try:
-            from .config import (
-                GRPCAuthConfig,
-                GRPCConfig,
-                GRPCProtoConfig,
-                GRPCServerConfig,
-            )
+            from .config import GRPCConfig
 
             return {
                 "GRPCConfig": GRPCConfig,
-                "GRPCServerConfig": GRPCServerConfig,
-                "GRPCAuthConfig": GRPCAuthConfig,
-                "GRPCProtoConfig": GRPCProtoConfig,
             }[name]
 
         except ImportError as e:

django_cfg/models/api/grpc/config.py

@@ -53,16 +53,21 @@ class GRPCServerConfig(BaseConfig):
         le=65535,
     )
 
-    max_workers: int = Field(
-        default=10,
-        description="ThreadPoolExecutor max workers",
+    max_concurrent_streams: Optional[int] = Field(
+        default=None,
+        description="Max concurrent streams per connection (None = unlimited, async server)",
         ge=1,
-        le=1000,
+        le=10000,
     )
 
-    enable_reflection: bool = Field(
+    asyncio_debug: bool = Field(
         default=False,
-        description="Enable server reflection for dynamic clients (grpcurl, etc.)",
+        description="Enable asyncio debug mode (shows async warnings and coroutine leaks)",
+    )
+
+    enable_reflection: bool = Field(
+        default=True,
+        description="Enable server reflection for grpcurl and other tools (enabled by default)",
     )
 
     enable_health_check: bool = Field(
@@ -70,6 +75,11 @@ class GRPCServerConfig(BaseConfig):
         description="Enable gRPC health check service",
     )
 
+    public_url: Optional[str] = Field(
+        default=None,
+        description="Public URL for clients (auto-generated from api_url if None)",
+    )
+
     compression: Optional[str] = Field(
         default=None,
         description="Compression algorithm: 'gzip', 'deflate', or None",
@@ -124,18 +134,59 @@ class GRPCServerConfig(BaseConfig):
             raise ValueError("Host cannot be empty")
         return v.strip()
 
+    @model_validator(mode="after")
+    def auto_set_smart_defaults(self) -> "GRPCServerConfig":
+        """Auto-set smart defaults based on Django settings."""
+        try:
+            from django_cfg.core import get_current_config
+            config = get_current_config()
+
+            if config:
+                # Auto-set public_url from api_url
+                if self.public_url is None and hasattr(config, 'api_url') and config.api_url:
+                    # https://api.djangocfg.com → grpc.djangocfg.com:50051
+                    url = config.api_url
+                    url = url.replace("https://", "").replace("http://", "")
+                    url = url.replace("api.", "grpc.")
+                    # Remove trailing slash
+                    url = url.rstrip("/")
+                    self.public_url = f"{url}:{self.port}"
+
+                # Auto-enable asyncio_debug in development mode
+                # Check if already explicitly set (if user set it, don't override)
+                # Only auto-enable if env_mode is development/local/dev
+                if hasattr(config, 'env_mode'):
+                    is_dev = config.env_mode in ("local", "development", "dev")
+                    # Only auto-enable if not explicitly set to False
+                    # We check if it's still the default value (False) and enable it in dev
+                    if is_dev and not self.asyncio_debug:
+                        # Check Django DEBUG setting as fallback
+                        try:
+                            from django.conf import settings
+                            if hasattr(settings, 'DEBUG') and settings.DEBUG:
+                                self.asyncio_debug = True
+                        except:
+                            # If Django not configured yet, just use env_mode
+                            self.asyncio_debug = True
+
+        except Exception:
+            # Config not available yet
+            pass
+
+        return self
+
 
 class GRPCAuthConfig(BaseConfig):
     """
     gRPC authentication configuration.
 
-    Supports JWT authentication with configurable token handling.
+    Uses API key authentication with Django ORM for secure, manageable access control.
 
     Example:
         >>> config = GRPCAuthConfig(
         ...     enabled=True,
-        ...     require_auth=True,
-        ...     jwt_algorithm="HS256"
+        ...     require_auth=False,
+        ...     accept_django_secret_key=True,
         ... )
     """
 
@@ -145,71 +196,31 @@ class GRPCAuthConfig(BaseConfig):
     )
 
     require_auth: bool = Field(
-        default=True,
+        default=False,  # Smart default: easy development
         description="Require authentication for all services (except public_methods)",
     )
 
-    token_header: str = Field(
-        default="authorization",
-        description="Metadata key for auth token",
+    # === API Key Authentication ===
+    api_key_header: str = Field(
+        default="x-api-key",
+        description="Metadata header name for API key (default: x-api-key)",
     )
 
-    token_prefix: str = Field(
-        default="Bearer",
-        description="Token prefix (e.g., 'Bearer' for JWT)",
-    )
-
-    jwt_secret_key: Optional[str] = Field(
-        default=None,
-        description="JWT secret key (defaults to Django SECRET_KEY if None)",
-    )
-
-    jwt_algorithm: str = Field(
-        default="HS256",
-        description="JWT signing algorithm",
-    )
-
-    jwt_verify_exp: bool = Field(
-        default=True,
-        description="Verify JWT expiration",
-    )
-
-    jwt_leeway: int = Field(
-        default=0,
-        description="JWT expiration leeway in seconds",
-        ge=0,
+    accept_django_secret_key: bool = Field(
+        default=True,  # Smart default: SECRET_KEY works for development
+        description="Accept Django SECRET_KEY as valid API key (for development/internal use)",
     )
 
+    # === Public Methods ===
     public_methods: List[str] = Field(
         default_factory=lambda: [
             "/grpc.health.v1.Health/Check",
             "/grpc.health.v1.Health/Watch",
+            "/grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo",
         ],
         description="RPC methods that don't require authentication",
     )
 
-    @field_validator("jwt_algorithm")
-    @classmethod
-    def validate_jwt_algorithm(cls, v: str) -> str:
-        """Validate JWT algorithm."""
-        valid_algorithms = {
-            "HS256",
-            "HS384",
-            "HS512",
-            "RS256",
-            "RS384",
-            "RS512",
-            "ES256",
-            "ES384",
-            "ES512",
-        }
-        if v not in valid_algorithms:
-            raise ValueError(
-                f"Invalid JWT algorithm: {v}. "
-                f"Must be one of: {', '.join(sorted(valid_algorithms))}"
-            )
-        return v
-
 
 class GRPCProtoConfig(BaseConfig):
     """
@@ -230,9 +241,9 @@ class GRPCProtoConfig(BaseConfig):
         description="Auto-generate proto files from Django models",
     )
 
-    output_dir: str = Field(
-        default="protos",
-        description="Proto files output directory (relative to BASE_DIR)",
+    output_dir: Optional[str] = Field(
+        default=None,
+        description="Proto files output directory (auto: media/protos if None)",
     )
 
     package_prefix: str = Field(
@@ -262,13 +273,23 @@ class GRPCProtoConfig(BaseConfig):
 
     @field_validator("output_dir")
     @classmethod
-    def validate_output_dir(cls, v: str) -> str:
+    def validate_output_dir(cls, v: Optional[str]) -> Optional[str]:
         """Validate output directory."""
-        if not v or not v.strip():
-            raise ValueError("output_dir cannot be empty")
+        if v is None:
+            return None
+        if not v.strip():
+            raise ValueError("output_dir cannot be empty string")
         # Remove leading/trailing slashes
         return v.strip().strip("/")
 
+    @model_validator(mode="after")
+    def auto_set_output_dir(self) -> "GRPCProtoConfig":
+        """Auto-set output_dir to media/protos if not specified."""
+        if self.output_dir is None:
+            # Better default: generated files go to media
+            self.output_dir = "media/protos"
+        return self
+
 
 class GRPCConfig(BaseConfig):
     """
@@ -277,15 +298,19 @@ class GRPCConfig(BaseConfig):
     Combines server, authentication, and proto generation settings.
 
     Example:
-        Basic setup:
-        >>> config = GRPCConfig(enabled=True)
+        Simple flat API (recommended):
+        >>> config = GRPCConfig(
+        ...     enabled=True,
+        ...     enabled_apps=["crypto"],
+        ...     package_prefix="api",
+        ... )
 
-        Advanced setup:
+        Advanced with nested configs (optional):
         >>> config = GRPCConfig(
         ...     enabled=True,
         ...     server=GRPCServerConfig(port=8080, max_workers=50),
         ...     auth=GRPCAuthConfig(require_auth=True),
-        ...     auto_register_apps=["accounts", "support"]
+        ...     enabled_apps=["accounts", "support"]
         ... )
     """
 
@@ -294,19 +319,55 @@ class GRPCConfig(BaseConfig):
         description="Enable gRPC integration",
     )
 
+    # === Flatten Server Config (most common settings) ===
+    # These are shortcuts that configure the nested server config
+    host: Optional[str] = Field(
+        default=None,
+        description="Server bind address (e.g., '[::]' for IPv6, '0.0.0.0' for IPv4). If None, uses server.host default",
+    )
+
+    port: Optional[int] = Field(
+        default=None,
+        description="Server port (e.g., 50051). If None, uses server.port default",
+        ge=1024,
+        le=65535,
+    )
+
+    public_url: Optional[str] = Field(
+        default=None,
+        description="Public URL for clients (e.g., 'grpc.djangocfg.com:443'). If None, auto-generated from api_url",
+    )
+
+    enable_reflection: Optional[bool] = Field(
+        default=None,
+        description="Enable server reflection for grpcurl/tools. If None, uses server.enable_reflection (True by default)",
+    )
+
+    # === Flatten Proto Config (most common settings) ===
+    package_prefix: Optional[str] = Field(
+        default=None,
+        description="Package prefix for proto files (e.g., 'api'). If None, uses proto.package_prefix default",
+    )
+
+    output_dir: Optional[str] = Field(
+        default=None,
+        description="Proto files output directory. If None, uses proto.output_dir default (media/protos)",
+    )
+
+    # === Nested Configs (for advanced use) ===
     server: GRPCServerConfig = Field(
         default_factory=GRPCServerConfig,
-        description="Server configuration",
+        description="Advanced server configuration (optional, use flatten fields above for common settings)",
     )
 
     auth: GRPCAuthConfig = Field(
         default_factory=GRPCAuthConfig,
-        description="Authentication configuration",
+        description="Authentication configuration (optional)",
     )
 
     proto: GRPCProtoConfig = Field(
         default_factory=GRPCProtoConfig,
-        description="Proto generation configuration",
+        description="Proto generation configuration (optional, use flatten fields above for common settings)",
     )
 
     handlers_hook: str = Field(
@@ -338,7 +399,28 @@ class GRPCConfig(BaseConfig):
 
     @model_validator(mode="after")
     def validate_grpc_config(self) -> "GRPCConfig":
-        """Cross-field validation."""
+        """
+        Cross-field validation and apply flatten fields to nested configs.
+
+        This allows users to configure common settings at the top level without
+        importing nested config classes.
+        """
+        # Apply flatten server fields to nested server config
+        if self.host is not None:
+            self.server.host = self.host
+        if self.port is not None:
+            self.server.port = self.port
+        if self.public_url is not None:
+            self.server.public_url = self.public_url
+        if self.enable_reflection is not None:
+            self.server.enable_reflection = self.enable_reflection
+
+        # Apply flatten proto fields to nested proto config
+        if self.package_prefix is not None:
+            self.proto.package_prefix = self.package_prefix
+        if self.output_dir is not None:
+            self.proto.output_dir = self.output_dir
+
         # Check dependencies if enabled
         if self.enabled:
             from django_cfg.apps.integrations.grpc._cfg import require_grpc_feature

django_cfg/models/ngrok/config.py

@@ -55,14 +55,15 @@ class NgrokConfig(BaseModel):
     def validate_enabled_in_debug_only(cls, v: bool) -> bool:
         """Ensure ngrok is only enabled in debug mode."""
         if v:
-            # Only check if Django is available and fully configured
+            # Use get_current_config() approach (same as GRPCServerConfig)
             try:
-                from django.conf import settings
-                # Only validate if settings are configured and DEBUG attribute exists
-                if settings.configured and hasattr(settings, 'DEBUG') and not settings.DEBUG:
+                from django_cfg.core import get_current_config
+
+                config = get_current_config()
+                if config and not config.debug:
                     raise ValueError("Ngrok can only be enabled in DEBUG mode")
-            except (ImportError, AttributeError, RuntimeError):
-                # Django not available, not configured, or settings not ready - skip validation
+            except Exception:
+                # Config not available yet - skip validation
                 pass
         return v
 

django_cfg/modules/django_client/core/generator/python/files_generator.py

@@ -161,20 +161,12 @@ class FilesGenerator:
         )
 
     def generate_schema_file(self, openapi_schema: dict) -> GeneratedFile:
-        """Generate schema.py with OpenAPI schema as dict."""
-        # First, convert to pretty JSON
-        schema_json = json.dumps(openapi_schema, indent=4, ensure_ascii=False)
-
-        # Convert JSON literals to Python literals
-        schema_json = re.sub(r'\btrue\b', 'True', schema_json)
-        schema_json = re.sub(r'\bfalse\b', 'False', schema_json)
-        schema_json = re.sub(r'\bnull\b', 'None', schema_json)
-
-        template = self.jinja_env.get_template('utils/schema.py.jinja')
-        content = template.render(schema_dict=schema_json)
+        """Generate schema.json with OpenAPI schema."""
+        # Generate JSON file with proper formatting
+        content = json.dumps(openapi_schema, indent=4, ensure_ascii=False)
 
         return GeneratedFile(
-            path="schema.py",
+            path="schema.json",
             content=content,
-            description="OpenAPI Schema",
+            description="OpenAPI Schema (JSON format)",
         )

django_cfg/modules/django_client/core/generator/python/templates/api_wrapper.py.jinja

@@ -127,14 +127,26 @@ class API:
         """Get current base URL."""
         return self.base_url
 
-    def get_schema(self) -> dict[str, Any]:
+    def get_schema_path(self) -> str:
         """
-        Get OpenAPI schema.
+        Get OpenAPI schema path.
 
         Returns:
-            Complete OpenAPI specification for this API
+            Path to the OpenAPI schema JSON file
+
+        Note:
+            The OpenAPI schema is available in the schema.json file.
+            You can load it dynamically using:
+            ```python
+            import json
+            from pathlib import Path
+
+            schema_path = Path(__file__).parent / 'schema.json'
+            with open(schema_path) as f:
+                schema = json.load(f)
+            ```
         """
-        return OPENAPI_SCHEMA
+        return './schema.json'
 
     async def __aenter__(self) -> 'API':
         """Async context manager entry."""

django_cfg/modules/django_client/core/generator/python/templates/main_init.py.jinja

@@ -18,8 +18,8 @@ Usage:
     >>> if api.is_authenticated():
     ...     # ...
     >>>
-    >>> # Get OpenAPI schema
-    >>> schema = api.get_schema()
+    >>> # Get OpenAPI schema path
+    >>> schema_path = api.get_schema_path()
 """
 
 from __future__ import annotations
@@ -30,7 +30,6 @@ from typing import Any
 import httpx
 
 from .client import APIClient
-from .schema import OPENAPI_SCHEMA
 from .logger import LoggerConfig
 from .retry import RetryConfig
 {% for tag in tags %}

django_cfg/modules/django_client/core/generator/typescript/files_generator.py

@@ -196,13 +196,14 @@ class FilesGenerator:
         )
 
     def generate_schema_file(self):
-        """Generate schema.ts with OpenAPI schema as const."""
+        """Generate schema.json with OpenAPI schema."""
+        import json
 
-        template = self.jinja_env.get_template('utils/schema.ts.jinja')
-        content = template.render(schema=self.openapi_schema)
+        # Generate JSON file with proper formatting
+        content = json.dumps(self.openapi_schema, indent=2, ensure_ascii=False)
 
         return GeneratedFile(
-            path="schema.ts",
+            path="schema.json",
             content=content,
-            description="OpenAPI Schema",
+            description="OpenAPI Schema (JSON format)",
         )