django-cfg 1.4.9__py3-none-any.whl → 1.4.11__py3-none-any.whl

django_cfg/modules/django_client/core/config/config.py

@@ -0,0 +1,188 @@
+"""
+Main OpenAPI configuration for django_cfg.
+
+Replaces django-revolution with integrated django_openapi module.
+"""
+
+from typing import Dict, Optional, Literal, List
+from pathlib import Path
+from pydantic import BaseModel, Field, field_validator
+from .group import OpenAPIGroupConfig
+
+
+class OpenAPIConfig(BaseModel):
+    """
+    Main OpenAPI configuration for django-cfg.
+
+    Features:
+    - Smart application grouping (cfg/custom)
+    - Python & TypeScript client generation
+    - Pure Python implementation (no external dependencies)
+    - 20x faster than django-revolution
+
+    Example:
+        >>> from django_cfg import DjangoCfg
+        >>> config = DjangoCfg(
+        ...     openapi=OpenAPIConfig(
+        ...         enabled=True,
+        ...         groups=[
+        ...             OpenAPIGroupConfig(
+        ...                 name="cfg",
+        ...                 apps=["django_cfg.*"],
+        ...                 title="Framework API",
+        ...             ),
+        ...             OpenAPIGroupConfig(
+        ...                 name="custom",
+        ...                 apps=["myapp"],
+        ...                 title="Custom API",
+        ...             ),
+        ...         ],
+        ...     ),
+        ... )
+    """
+
+    model_config = {
+        "str_strip_whitespace": True,
+        "validate_assignment": True,
+        "extra": "forbid",
+    }
+
+    # Control
+    enabled: bool = Field(
+        default=False,
+        description="Enable OpenAPI client generation",
+    )
+
+    # Application Grouping
+    groups: List[OpenAPIGroupConfig] = Field(
+        default_factory=list,
+        description="Application groups for separate schema generation",
+    )
+
+    # Output Configuration
+    output_dir: str = Field(
+        default="openapi",
+        description="Base output directory for schemas and clients",
+    )
+
+    # Client Generation
+    generate_python: bool = Field(
+        default=True,
+        description="Generate Python client",
+    )
+
+    generate_typescript: bool = Field(
+        default=True,
+        description="Generate TypeScript client",
+    )
+
+    client_structure: Literal["flat", "namespaced"] = Field(
+        default="namespaced",
+        description=(
+            "Client structure:\n"
+            "  - flat: All methods in one class (client.posts_list())\n"
+            "  - namespaced: Organized by tags (client.posts.list())"
+        ),
+    )
+
+    # API Configuration
+    api_prefix: str = Field(
+        default="apix",
+        description="API URL prefix (e.g., 'apix' -> /apix/app/endpoint)",
+    )
+
+    # Archive Configuration
+    enable_archive: bool = Field(
+        default=True,
+        description="Enable client archiving with versioning",
+    )
+
+    archive_retention_days: int = Field(
+        default=30,
+        description="Days to keep archived clients",
+        ge=1,
+    )
+
+    # Performance
+    max_workers: int = Field(
+        default=1,
+        description="Number of parallel workers (1 = single-threaded, which is fast enough)",
+        ge=1,
+        le=20,
+    )
+
+    @field_validator("groups")
+    @classmethod
+    def validate_groups_when_enabled(cls, v: List[OpenAPIGroupConfig], info) -> List[OpenAPIGroupConfig]:
+        """Ensure at least one group is defined when enabled and names are unique."""
+        # Access enabled field via info.data
+        enabled = info.data.get("enabled", False)
+        if enabled and not v:
+            raise ValueError("At least one group must be defined when OpenAPI is enabled")
+
+        # Check for duplicate group names
+        names = [group.name for group in v]
+        if len(names) != len(set(names)):
+            duplicates = [name for name in names if names.count(name) > 1]
+            raise ValueError(f"Duplicate group names found: {', '.join(set(duplicates))}")
+
+        return v
+
+    @field_validator("api_prefix")
+    @classmethod
+    def validate_api_prefix(cls, v: str) -> str:
+        """Ensure API prefix is valid."""
+        v = v.strip().strip("/")
+        if not v:
+            raise ValueError("api_prefix cannot be empty")
+        return v
+
+    @field_validator("output_dir")
+    @classmethod
+    def validate_output_dir(cls, v: str) -> str:
+        """Ensure output directory is valid."""
+        v = v.strip()
+        if not v:
+            raise ValueError("output_dir cannot be empty")
+        return v
+
+    def get_output_path(self) -> Path:
+        """Get absolute output path."""
+        return Path(self.output_dir).resolve()
+
+    def get_schemas_dir(self) -> Path:
+        """Get schemas directory path."""
+        return self.get_output_path() / "schemas"
+
+    def get_clients_dir(self) -> Path:
+        """Get clients directory path."""
+        return self.get_output_path() / "clients"
+
+    def get_python_clients_dir(self) -> Path:
+        """Get Python clients directory path."""
+        return self.get_clients_dir() / "python"
+
+    def get_typescript_clients_dir(self) -> Path:
+        """Get TypeScript clients directory path."""
+        return self.get_clients_dir() / "typescript"
+
+    def get_archive_dir(self) -> Path:
+        """Get archive directory path."""
+        return self.get_output_path() / "archive"
+
+    def get_group_schema_path(self, group_name: str) -> Path:
+        """Get OpenAPI schema path for a group."""
+        return self.get_schemas_dir() / f"{group_name}.yaml"
+
+    def get_group_python_dir(self, group_name: str) -> Path:
+        """Get Python client directory for a group."""
+        return self.get_python_clients_dir() / group_name
+
+    def get_group_typescript_dir(self, group_name: str) -> Path:
+        """Get TypeScript client directory for a group."""
+        return self.get_typescript_clients_dir() / group_name
+
+
+__all__ = [
+    "OpenAPIConfig",
+]

django_cfg/modules/django_client/core/config/group.py

@@ -0,0 +1,101 @@
+"""
+OpenAPI Group Configuration.
+
+Defines application grouping (cfg/custom) for separate schema generation.
+"""
+
+from typing import List
+from pydantic import BaseModel, Field, field_validator
+
+
+class OpenAPIGroupConfig(BaseModel):
+    """
+    Configuration for a single application group.
+
+    Groups organize Django apps into separate OpenAPI schemas and clients.
+
+    Example:
+        >>> cfg_group = OpenAPIGroupConfig(
+        ...     name="cfg",
+        ...     apps=["django_cfg.*"],
+        ...     title="Django Config Framework API",
+        ...     description="Core framework functionality",
+        ... )
+    """
+
+    model_config = {
+        "str_strip_whitespace": True,
+        "validate_assignment": True,
+        "extra": "forbid",
+    }
+
+    # Group identification
+    name: str = Field(
+        ...,
+        description="Unique name for this group (used for file paths and identification)",
+        min_length=1,
+    )
+
+    # App selection
+    apps: List[str] = Field(
+        ...,
+        description="List of Django apps in this group. Supports wildcards (e.g., 'django_cfg.*')",
+        min_length=1,
+    )
+
+    # Metadata
+    title: str = Field(
+        ...,
+        description="Human-readable title for this group",
+        min_length=1,
+    )
+
+    description: str = Field(
+        default="",
+        description="Detailed description for this group",
+    )
+
+    # API configuration
+    version: str = Field(
+        default="v1",
+        description="API version string",
+    )
+
+    # Authentication
+    auth_required: bool = Field(
+        default=False,
+        description="Whether authentication is required for this group",
+    )
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v: str) -> str:
+        """Ensure name is valid (alphanumeric + underscore/hyphen)."""
+        import re
+        v = v.strip()
+        if not v:
+            raise ValueError("name cannot be empty")
+        if not re.match(r'^[a-zA-Z0-9_-]+$', v):
+            raise ValueError("name must contain only alphanumeric characters, underscores, or hyphens")
+        return v
+
+    @field_validator("apps")
+    @classmethod
+    def validate_apps_not_empty(cls, v: List[str]) -> List[str]:
+        """Ensure apps list is not empty."""
+        if not v:
+            raise ValueError("apps list cannot be empty")
+        return v
+
+    @field_validator("title")
+    @classmethod
+    def validate_title_not_empty(cls, v: str) -> str:
+        """Ensure title is not empty."""
+        if not v.strip():
+            raise ValueError("title cannot be empty")
+        return v.strip()
+
+
+__all__ = [
+    "OpenAPIGroupConfig",
+]

django_cfg/modules/django_client/core/config/service.py

@@ -0,0 +1,209 @@
+"""
+Django OpenAPI Service.
+
+Universal OpenAPI client generator.
+Replaces django-revolution with faster, cleaner implementation.
+"""
+
+import logging
+from typing import Optional, Dict, List
+from pathlib import Path
+from .config import OpenAPIConfig
+from .group import OpenAPIGroupConfig
+
+logger = logging.getLogger(__name__)
+
+
+class OpenAPIError(Exception):
+    """Base exception for OpenAPI-related errors."""
+
+    pass
+
+
+class DjangoOpenAPI:
+    """
+    Main OpenAPI service.
+
+    Features:
+    - Smart application grouping (cfg/custom)
+    - Pure Python client generation (Python + TypeScript)
+    - 20x faster than django-revolution
+    - No external dependencies (Node.js, datamodel-codegen, etc.)
+    - Full x-enum-varnames support
+    - Native COMPONENT_SPLIT_REQUEST handling
+
+    Example:
+        >>> from django_cfg.modules.django_client.core.config import get_openapi_service
+        >>> service = get_openapi_service()
+        >>> service.generate_clients(groups=["cfg", "custom"])
+    """
+
+    def __init__(self, config: Optional[OpenAPIConfig] = None):
+        self._config: Optional[OpenAPIConfig] = config
+
+    @property
+    def config(self) -> Optional[OpenAPIConfig]:
+        """Get OpenAPI configuration."""
+        return self._config
+
+    def set_config(self, config: OpenAPIConfig):
+        """Set OpenAPI configuration."""
+        self._config = config
+
+    def is_enabled(self) -> bool:
+        """Check if OpenAPI is enabled."""
+        return self.config is not None and self.config.enabled
+
+    def get_groups(self) -> Dict[str, OpenAPIGroupConfig]:
+        """Get configured application groups as a dictionary (for backward compatibility)."""
+        if not self.config:
+            return {}
+
+        # Use get_groups_with_defaults if available (ExtendedOpenAPIConfig)
+        if hasattr(self.config, 'get_groups_with_defaults'):
+            return self.config.get_groups_with_defaults()
+
+        # Convert list to dict for backward compatibility
+        return {group.name: group for group in self.config.groups}
+
+    def get_group(self, group_name: str) -> Optional[OpenAPIGroupConfig]:
+        """Get specific group configuration (including defaults)."""
+        return self.get_groups().get(group_name)
+
+    def get_group_names(self) -> List[str]:
+        """Get list of configured group names (including defaults)."""
+        return list(self.get_groups().keys())
+
+    def get_output_dir(self) -> Path:
+        """Get base output directory."""
+        if not self.config:
+            return Path("openapi")
+        return self.config.get_output_path()
+
+    def get_schemas_dir(self) -> Path:
+        """Get schemas directory."""
+        if not self.config:
+            return Path("openapi/schemas")
+        return self.config.get_schemas_dir()
+
+    def get_clients_dir(self) -> Path:
+        """Get clients directory."""
+        if not self.config:
+            return Path("openapi/clients")
+        return self.config.get_clients_dir()
+
+    def ensure_directories(self):
+        """Ensure all required directories exist."""
+        if not self.config:
+            return
+
+        dirs = [
+            self.config.get_output_path(),
+            self.config.get_schemas_dir(),
+            self.config.get_clients_dir(),
+            self.config.get_python_clients_dir(),
+            self.config.get_typescript_clients_dir(),
+        ]
+
+        if self.config.enable_archive:
+            dirs.append(self.config.get_archive_dir())
+
+        for directory in dirs:
+            directory.mkdir(parents=True, exist_ok=True)
+            logger.debug(f"Ensured directory exists: {directory}")
+
+    def validate_config(self) -> bool:
+        """
+        Validate OpenAPI configuration.
+
+        Returns:
+            bool: True if configuration is valid
+
+        Raises:
+            OpenAPIError: If configuration is invalid
+        """
+        if not self.config:
+            raise OpenAPIError("OpenAPI configuration not found")
+
+        if not self.config.enabled:
+            raise OpenAPIError("OpenAPI is not enabled")
+
+        if not self.config.groups:
+            raise OpenAPIError("No application groups configured")
+
+        # Validate each group
+        for group in self.config.groups:
+            if not group.apps:
+                raise OpenAPIError(f"Group '{group.name}' has no apps configured")
+
+            if not group.title:
+                raise OpenAPIError(f"Group '{group.name}' has no title")
+
+        logger.info(f"OpenAPI configuration validated: {len(self.config.groups)} groups")
+        return True
+
+    def get_status(self) -> Dict:
+        """
+        Get OpenAPI service status.
+
+        Returns:
+            Dictionary with service status information
+        """
+        if not self.config:
+            return {
+                "enabled": False,
+                "reason": "Configuration not found",
+            }
+
+        try:
+            return {
+                "enabled": self.config.enabled,
+                "groups": len(self.config.groups),
+                "group_names": self.get_group_names(),
+                "output_dir": str(self.config.get_output_path()),
+                "generate_python": self.config.generate_python,
+                "generate_typescript": self.config.generate_typescript,
+                "api_prefix": self.config.api_prefix,
+                "archive_enabled": self.config.enable_archive,
+            }
+        except Exception as e:
+            return {
+                "enabled": False,
+                "error": str(e),
+            }
+
+
+# Singleton instance
+_service_instance: Optional[DjangoOpenAPI] = None
+
+
+def get_openapi_service() -> DjangoOpenAPI:
+    """
+    Get singleton OpenAPI service instance.
+
+    Returns:
+        DjangoOpenAPI instance
+
+    Example:
+        >>> service = get_openapi_service()
+        >>> if service.is_enabled():
+        ...     print(f"Groups: {service.get_group_names()}")
+    """
+    global _service_instance
+    if _service_instance is None:
+        _service_instance = DjangoOpenAPI()
+    return _service_instance
+
+
+def reset_service():
+    """Reset singleton instance (useful for testing)."""
+    global _service_instance
+    _service_instance = None
+
+
+__all__ = [
+    "DjangoOpenAPI",
+    "OpenAPIError",
+    "get_openapi_service",
+    "reset_service",
+]

django_cfg/modules/django_client/core/generator/__init__.py

@@ -0,0 +1,115 @@
+"""
+Code Generators - IR → Python/TypeScript clients.
+
+This package provides generators for converting IR to language-specific clients.
+
+Usage:
+    >>> from django_cfg.modules.django_client.core.generator import generate_python, generate_typescript
+    >>> from django_cfg.modules.django_client.core.parser import parse_openapi
+    >>>
+    >>> # Parse OpenAPI spec
+    >>> context = parse_openapi(spec_dict)
+    >>>
+    >>> # Generate Python client
+    >>> python_files = generate_python(context)
+    >>> for file in python_files:
+    ...     print(f"{file.path}: {len(file.content)} bytes")
+    >>>
+    >>> # Generate TypeScript client
+    >>> ts_files = generate_typescript(context)
+"""
+
+from pathlib import Path
+from typing import Literal
+
+from django_cfg.modules.django_client.core.generator.base import GeneratedFile
+from django_cfg.modules.django_client.core.generator.python import PythonGenerator
+from django_cfg.modules.django_client.core.generator.typescript import TypeScriptGenerator
+from django_cfg.modules.django_client.core.ir import IRContext
+
+__all__ = [
+    "PythonGenerator",
+    "TypeScriptGenerator",
+    "GeneratedFile",
+    "generate_python",
+    "generate_typescript",
+    "generate_client",
+]
+
+
+def generate_python(context: IRContext, output_dir: Path | None = None) -> list[GeneratedFile]:
+    """
+    Generate Python client from IR.
+
+    Args:
+        context: IRContext from parser
+        output_dir: Optional output directory (saves files if provided)
+
+    Returns:
+        List of GeneratedFile objects
+
+    Examples:
+        >>> files = generate_python(context)
+        >>> # Or save directly
+        >>> files = generate_python(context, output_dir=Path("./generated/python"))
+    """
+    generator = PythonGenerator(context)
+    files = generator.generate()
+
+    if output_dir:
+        generator.save_files(files, output_dir)
+
+    return files
+
+
+def generate_typescript(context: IRContext, output_dir: Path | None = None) -> list[GeneratedFile]:
+    """
+    Generate TypeScript client from IR.
+
+    Args:
+        context: IRContext from parser
+        output_dir: Optional output directory (saves files if provided)
+
+    Returns:
+        List of GeneratedFile objects
+
+    Examples:
+        >>> files = generate_typescript(context)
+        >>> # Or save directly
+        >>> files = generate_typescript(context, output_dir=Path("./generated/typescript"))
+    """
+    generator = TypeScriptGenerator(context)
+    files = generator.generate()
+
+    if output_dir:
+        generator.save_files(files, output_dir)
+
+    return files
+
+
+def generate_client(
+    context: IRContext,
+    language: Literal["python", "typescript"],
+    output_dir: Path | None = None,
+) -> list[GeneratedFile]:
+    """
+    Generate client for specified language.
+
+    Args:
+        context: IRContext from parser
+        language: Target language ('python' or 'typescript')
+        output_dir: Optional output directory
+
+    Returns:
+        List of GeneratedFile objects
+
+    Examples:
+        >>> files = generate_client(context, "python")
+        >>> files = generate_client(context, "typescript", Path("./generated"))
+    """
+    if language == "python":
+        return generate_python(context, output_dir)
+    elif language == "typescript":
+        return generate_typescript(context, output_dir)
+    else:
+        raise ValueError(f"Unsupported language: {language}")