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

django_cfg/modules/django_client/__init__.py

@@ -0,0 +1,20 @@
+"""
+Django Client - Django integration for openapi_client.
+
+Provides Django management commands and URL integration.
+"""
+
+# Django AppConfig
+default_app_config = 'django_cfg.modules.django_client.apps.DjangoClientConfig'
+
+# Re-export everything from openapi_client
+from django_cfg.modules.django_client.core import *  # noqa
+
+# Django-specific
+from .management.commands.generate_client import Command as GenerateClientCommand
+from .urls import get_openapi_urls
+
+__all__ = [
+    "GenerateClientCommand",
+    "get_openapi_urls",
+]

django_cfg/modules/django_client/apps.py

@@ -0,0 +1,35 @@
+"""
+Django Client AppConfig.
+
+Initializes OpenAPI service with configuration from Django settings.
+"""
+
+from django.apps import AppConfig
+from django.conf import settings
+
+
+class DjangoClientConfig(AppConfig):
+    """AppConfig for django_client."""
+
+    name = 'django_cfg.modules.django_client'
+    verbose_name = 'Django OpenAPI Client'
+    default_auto_field = 'django.db.models.BigAutoField'
+
+    def ready(self):
+        """Initialize OpenAPI service on app startup."""
+        # Import here to avoid AppRegistryNotReady
+        from django_cfg.modules.django_client.core import get_openapi_service
+        from django_cfg.core.state.registry import get_current_config
+
+        # Get config from django-cfg
+        django_config = get_current_config()
+        if not django_config or not hasattr(django_config, 'openapi_client'):
+            return
+
+        config = django_config.openapi_client
+
+        if config and config.enabled:
+            # Initialize service with config
+            service = get_openapi_service()
+            service.set_config(config)
+            print(f"✅ Django Client initialized with {len(config.groups)} groups")

django_cfg/modules/django_client/core/__init__.py

@@ -0,0 +1,56 @@
+"""
+OpenAPI Client Generator.
+
+Universal, pure Python OpenAPI client generator.
+No Django dependencies - can be used standalone or with any framework.
+"""
+
+__version__ = "1.0.0"
+
+# Configuration
+from .config import (
+    OpenAPIConfig,
+    OpenAPIGroupConfig,
+    DjangoOpenAPI,
+    OpenAPIError,
+    get_openapi_service,
+)
+
+# Groups
+from .groups import GroupManager, GroupDetector
+
+# Archive
+from .archive import ArchiveManager
+
+# IR Models
+from .ir import (
+    IRContext,
+    IROperationObject,
+    IRSchemaObject,
+)
+
+# Parsers
+from .parser import parse_openapi, OpenAPI30Parser, OpenAPI31Parser
+
+# Generators
+from .generator import PythonGenerator, TypeScriptGenerator
+
+__all__ = [
+    "__version__",
+    "OpenAPIConfig",
+    "OpenAPIGroupConfig",
+    "DjangoOpenAPI",
+    "OpenAPIError",
+    "get_openapi_service",
+    "GroupManager",
+    "GroupDetector",
+    "ArchiveManager",
+    "IRContext",
+    "IROperationObject",
+    "IRSchemaObject",
+    "parse_openapi",
+    "OpenAPI30Parser",
+    "OpenAPI31Parser",
+    "PythonGenerator",
+    "TypeScriptGenerator",
+]

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

@@ -0,0 +1,11 @@
+"""
+Archive management for django-client.
+
+Simplified versioning without heavy dependencies.
+"""
+
+from .manager import ArchiveManager
+
+__all__ = [
+    "ArchiveManager",
+]

django_cfg/modules/django_client/core/archive/manager.py

@@ -0,0 +1,134 @@
+"""
+Simple Archive Manager.
+
+Lightweight client archiving without complex dependencies.
+"""
+
+import shutil
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Dict
+
+
+class ArchiveManager:
+    """
+    Simple archive manager for generated clients.
+
+    Creates timestamped copies + 'latest' symlink.
+    """
+
+    def __init__(self, base_dir: Path):
+        """
+        Initialize archive manager.
+
+        Args:
+            base_dir: Base directory for archives
+        """
+        self.base_dir = Path(base_dir)
+        self.archive_dir = self.base_dir / "archive"
+        self.archive_dir.mkdir(parents=True, exist_ok=True)
+
+    def archive_clients(
+        self,
+        group_name: str,
+        python_dir: Optional[Path] = None,
+        typescript_dir: Optional[Path] = None,
+    ) -> Dict:
+        """
+        Archive generated clients.
+
+        Args:
+            group_name: Name of the group
+            python_dir: Python client directory
+            typescript_dir: TypeScript client directory
+
+        Returns:
+            Archive result dictionary
+        """
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+        # Create timestamped directory
+        archive_path = self.archive_dir / timestamp / group_name
+        archive_path.mkdir(parents=True, exist_ok=True)
+
+        # Copy clients
+        copied = {}
+
+        if python_dir and python_dir.exists():
+            dest = archive_path / "python"
+            shutil.copytree(python_dir, dest)
+            copied["python"] = str(dest)
+
+        if typescript_dir and typescript_dir.exists():
+            dest = archive_path / "typescript"
+            shutil.copytree(typescript_dir, dest)
+            copied["typescript"] = str(dest)
+
+        # Create metadata
+        metadata = {
+            "group": group_name,
+            "timestamp": timestamp,
+            "datetime": datetime.now().isoformat(),
+            "clients": copied,
+        }
+
+        metadata_file = archive_path / "metadata.json"
+        metadata_file.write_text(json.dumps(metadata, indent=2))
+
+        # Create/update 'latest' symlink
+        latest_link = self.archive_dir / "latest" / group_name
+        latest_link.parent.mkdir(parents=True, exist_ok=True)
+
+        if latest_link.exists() or latest_link.is_symlink():
+            latest_link.unlink()
+
+        try:
+            latest_link.symlink_to(archive_path, target_is_directory=True)
+        except OSError:
+            # Fallback: copy instead of symlink (Windows)
+            if latest_link.exists():
+                shutil.rmtree(latest_link)
+            shutil.copytree(archive_path, latest_link)
+
+        return {
+            "success": True,
+            "archive_path": str(archive_path),
+            "timestamp": timestamp,
+            "clients": list(copied.keys()),
+        }
+
+    def list_archives(self, group_name: Optional[str] = None) -> list:
+        """
+        List available archives.
+
+        Args:
+            group_name: Optional group filter
+
+        Returns:
+            List of archive info dictionaries
+        """
+        archives = []
+
+        for timestamp_dir in sorted(self.archive_dir.iterdir()):
+            if timestamp_dir.name == "latest":
+                continue
+
+            if not timestamp_dir.is_dir():
+                continue
+
+            for group_dir in timestamp_dir.iterdir():
+                if group_name and group_dir.name != group_name:
+                    continue
+
+                metadata_file = group_dir / "metadata.json"
+                if metadata_file.exists():
+                    metadata = json.loads(metadata_file.read_text())
+                    archives.append(metadata)
+
+        return archives
+
+
+__all__ = [
+    "ArchiveManager",
+]

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

@@ -0,0 +1,12 @@
+"""
+CLI Module for django-client.
+
+Interactive command-line interface with rich output.
+"""
+
+from .main import main, run_cli
+
+__all__ = [
+    "main",
+    "run_cli",
+]

django_cfg/modules/django_client/core/cli/main.py

@@ -0,0 +1,235 @@
+"""
+Django Client CLI - Command-line interface with click.
+
+Provides intuitive CLI for client generation.
+"""
+
+import sys
+from pathlib import Path
+from typing import Optional, List
+
+try:
+    import click
+    CLICK_AVAILABLE = True
+except ImportError:
+    CLICK_AVAILABLE = False
+    click = None
+
+try:
+    from rich.console import Console
+    from rich.table import Table
+    RICH_AVAILABLE = True
+except ImportError:
+    RICH_AVAILABLE = False
+    Console = None
+
+
+console = Console() if RICH_AVAILABLE else None
+
+
+def print_message(message: str, style: str = ""):
+    """Print message with optional styling."""
+    if console:
+        console.print(message, style=style)
+    else:
+        print(message)
+
+
+def print_error(message: str):
+    """Print error message."""
+    if console:
+        console.print(f"❌ {message}", style="bold red")
+    else:
+        print(f"ERROR: {message}")
+
+
+def print_success(message: str):
+    """Print success message."""
+    if console:
+        console.print(f"✅ {message}", style="bold green")
+    else:
+        print(f"SUCCESS: {message}")
+
+
+def print_info(message: str):
+    """Print info message."""
+    if console:
+        console.print(f"ℹ️  {message}", style="bold blue")
+    else:
+        print(f"INFO: {message}")
+
+
+def print_warning(message: str):
+    """Print warning message."""
+    if console:
+        console.print(f"⚠️  {message}", style="bold yellow")
+    else:
+        print(f"WARNING: {message}")
+
+
+@click.group(invoke_without_command=True)
+@click.option('--version', is_flag=True, help='Show version')
+@click.pass_context
+def cli(ctx, version):
+    """
+    Django Client - Universal OpenAPI Client Generator.
+
+    Fast, pure Python implementation with TypeScript and Python support.
+    """
+    if version:
+        print_message("Django Client v1.0.0", style="bold cyan")
+        ctx.exit(0)
+
+    if ctx.invoked_subcommand is None:
+        click.echo(ctx.get_help())
+
+
+@cli.command()
+@click.option('--groups', '-g', multiple=True, help='Specific groups to generate')
+@click.option('--python/--no-python', default=True, help='Generate Python client')
+@click.option('--typescript/--no-typescript', default=True, help='Generate TypeScript client')
+@click.option('--dry-run', is_flag=True, help='Validate without generating files')
+@click.option('--config', type=click.Path(exists=True), help='Path to config file')
+def generate(groups, python, typescript, dry_run, config):
+    """Generate API clients for configured groups."""
+    try:
+        if dry_run:
+            print_info("DRY RUN MODE - No files will be generated")
+
+        groups_list = list(groups) if groups else None
+        print_info(f"Generating clients for groups: {groups_list or 'all'}")
+
+        if python:
+            print_message("  → Python client", style="cyan")
+        if typescript:
+            print_message("  → TypeScript client", style="cyan")
+
+        # TODO: Actual generation logic
+
+        if not dry_run:
+            print_success("Client generation completed!")
+        else:
+            print_info("Dry run completed - no files generated")
+
+    except Exception as e:
+        print_error(f"Generation failed: {e}")
+        sys.exit(1)
+
+
+@cli.command('list-groups')
+@click.option('--config', type=click.Path(exists=True), help='Path to config file')
+def list_groups(config):
+    """List configured application groups."""
+    try:
+        from django_cfg.modules.django_client.core import get_openapi_service
+
+        service = get_openapi_service()
+
+        if not service.config:
+            print_warning("No configuration found")
+            return
+
+        groups = service.get_groups()
+
+        if not groups:
+            print_warning("No groups configured")
+            return
+
+        print_info(f"Configured groups ({len(groups)}):")
+
+        if console:
+            table = Table(title="Application Groups")
+            table.add_column("Group", style="cyan", no_wrap=True)
+            table.add_column("Title", style="green")
+            table.add_column("Apps", style="yellow")
+
+            for name, group_config in groups.items():
+                table.add_row(
+                    name,
+                    group_config.title,
+                    str(len(group_config.apps))
+                )
+
+            console.print(table)
+        else:
+            for name, group_config in groups.items():
+                print(f"\n  • {name}")
+                print(f"    Title: {group_config.title}")
+                print(f"    Apps: {len(group_config.apps)} pattern(s)")
+
+    except Exception as e:
+        print_error(f"Failed to list groups: {e}")
+        sys.exit(1)
+
+
+@cli.command()
+@click.option('--config', type=click.Path(exists=True), help='Path to config file')
+def validate(config):
+    """Validate configuration."""
+    try:
+        from django_cfg.modules.django_client.core import get_openapi_service
+
+        print_info("Validating configuration...")
+
+        service = get_openapi_service()
+
+        if not service.config:
+            print_error("No configuration found")
+            sys.exit(1)
+
+        service.validate_config()
+        print_success("Configuration is valid!")
+
+    except Exception as e:
+        print_error(f"Validation failed: {e}")
+        sys.exit(1)
+
+
+@cli.command()
+@click.option('--config', type=click.Path(exists=True), help='Path to config file')
+def status(config):
+    """Show current status and configuration."""
+    try:
+        from django_cfg.modules.django_client.core import get_openapi_service
+
+        service = get_openapi_service()
+
+        if not service.config:
+            print_warning("No configuration found")
+            return
+
+        status_info = service.get_status()
+
+        print_info("Django Client Status:")
+        print(f"\n  Enabled: {status_info.get('enabled', False)}")
+        print(f"  Groups: {status_info.get('groups', 0)}")
+        print(f"  Output: {status_info.get('output_dir', 'N/A')}")
+        print(f"  Python: {status_info.get('generate_python', False)}")
+        print(f"  TypeScript: {status_info.get('generate_typescript', False)}")
+
+        if status_info.get('group_names'):
+            print(f"\n  Configured groups:")
+            for name in status_info['group_names']:
+                print(f"    • {name}")
+
+    except Exception as e:
+        print_error(f"Failed to get status: {e}")
+        sys.exit(1)
+
+
+def main():
+    """Main entry point."""
+    if not CLICK_AVAILABLE:
+        print("ERROR: click is required. Install with: pip install click")
+        sys.exit(1)
+
+    cli()
+
+
+def run_cli():
+    """Run CLI (alias for main)."""
+    main()
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,18 @@
+"""
+Django Client Configuration.
+
+Configuration models and service for OpenAPI client generation.
+"""
+
+from .config import OpenAPIConfig
+from .group import OpenAPIGroupConfig
+from .service import DjangoOpenAPI, OpenAPIError, get_openapi_service, reset_service
+
+__all__ = [
+    "OpenAPIConfig",
+    "OpenAPIGroupConfig",
+    "DjangoOpenAPI",
+    "OpenAPIError",
+    "get_openapi_service",
+    "reset_service",
+]