API Reference - Django Revolution

from django_revolution.app_config import ZoneConfig, get_revolution_config

# Create zone configuration
zone = ZoneConfig(
    apps=['accounts', 'billing'],
    title='Public API',
    description='Public endpoints',
    public=True,
    auth_required=False,
    version='v1'
)

# Create Django Revolution configuration
DJANGO_REVOLUTION = get_revolution_config(
    project_root=BASE_DIR,
    zones=zones,
    debug=DEBUG
)

# Get Django Revolution settings
from django_revolution.config import get_settings
settings = get_settings()
print(settings.zones)

from django_revolution.app_config import MonorepoConfig, MonorepoSettings, get_revolution_config

# Configure multiple monorepos
monorepo_settings = MonorepoSettings(
    enabled=True,
    configurations=[
        # Main frontend monorepo
        MonorepoConfig(
            name="frontend",
            enabled=True,
            path=str(BASE_DIR.parent / 'monorepo'),
            api_package_path='packages/api'
        ),
        # Mobile app monorepo
        MonorepoConfig(
            name="mobile",
            enabled=True,
            path=str(BASE_DIR.parent / 'mobile-monorepo'),
            api_package_path='packages/api-client'
        ),
        # Admin panel monorepo
        MonorepoConfig(
            name="admin",
            enabled=False,  # Disabled for now
            path=str(BASE_DIR.parent / 'admin-monorepo'),
            api_package_path='packages/admin-api'
        ),
    ]
)

# Create Django Revolution configuration with monorepo
DJANGO_REVOLUTION = get_revolution_config(
    project_root=BASE_DIR,
    zones=zones,
    monorepo=monorepo_settings,
    debug=DEBUG
)

from django_revolution.zones import DynamicZoneManager

zone_manager = DynamicZoneManager()

# Create URL configuration module in-memory
urlconf_module = zone_manager.create_dynamic_urlconf_module('public', zone_config)

# Detect Django apps that belong to a zone
apps = zone_manager.detect_apps_in_zone(zone_config)

# Validate zone configuration and dependencies
is_valid = zone_manager.validate_zone_configuration('public', zone_config)

from django_revolution.openapi.generator import OpenAPIGenerator

generator = OpenAPIGenerator(config)

# Generate OpenAPI schemas for all zones
schemas = generator.generate_schemas()

# Generate TypeScript client using @hey-api/openapi-ts
ts_client = generator.generate_typescript_client()

# Generate Python client using datamodel-code-generator
py_client = generator.generate_python_client()

# Generate archive of all clients
archive = generator.generate_archive()

from django_revolution.drf_config import create_drf_config

# Create DRF and Spectacular configuration
drf_config = create_drf_config(
    title='My API',
    description='My awesome API',
    version='1.0.0',
    schema_path_prefix='/apix/',
    enable_browsable_api=False,
    enable_throttling=False
)

# Get REST framework settings
rest_framework_settings = drf_config.get_rest_framework_settings()

# Get Spectacular settings
spectacular_settings = drf_config.get_spectacular_settings()

# Get all Django settings
django_settings = drf_config.get_django_settings()

from django_revolution.urls_integration import add_revolution_urls, get_revolution_urlpatterns, get_revolution_urls_info

# Add Django Revolution URLs to your URL patterns
urlpatterns = [
    # Your existing URLs
]
urlpatterns = add_revolution_urls(urlpatterns)

# Get Django Revolution URL patterns
urlpatterns = [
    # Your existing URLs
    *get_revolution_urlpatterns()
]

# Get information about generated URLs
urls_info = get_revolution_urls_info()
for zone, info in urls_info.items():
    print(f"Zone: {zone}")
    print(f"  Schema URL: {info['schema_url']}")
    print(f"  API URL: {info['api_url']}")

from django_revolution.zones import DynamicZoneDetector

detector = DynamicZoneDetector()

# Detect apps in project
apps = detector.detect_apps()

# Get URL patterns for app
patterns = detector.get_app_url_patterns('accounts')

# Validate app exists
exists = detector.app_exists('accounts')

from scripts.version_manager import VersionManager

version_manager = VersionManager()

# Get current version
version = version_manager.get_current_version()

# Bump version
new_version = version_manager.bump_version('patch')

# Validate version consistency
is_consistent = version_manager.validate_version_consistency()

# Regenerate requirements
version_manager.regenerate_requirements()

from scripts.publisher import main as publish

# Interactive publishing
exit_code = publish()

from django_revolution.cli import main

# Run CLI
exit_code = main()

from scripts.dev_cli import main as dev_cli

# Run development CLI
dev_cli()

from django_revolution.utils import auto_install_dependencies

success = auto_install_dependencies()
if success:
    print("✅ Dependencies installed")
else:
    print("❌ Failed to install dependencies")

from django_revolution.utils import run_command

success, output = run_command("npm install @hey-api/openapi-ts")
if success:
    print(f"✅ Command succeeded: {output}")
else:
    print(f"❌ Command failed: {output}")

from django_revolution.utils import ensure_directories
from pathlib import Path

success = ensure_directories(
    Path("openapi/schemas"),
    Path("clients/typescript"),
    Path("clients/python")
)

from django_revolution.utils import render_template

template = "Hello {{ name }}!"
context = {"name": "World"}
result = render_template(template, context)
# Result: "Hello World!"

from django_revolution.zones import validate_zone_configuration

is_valid = validate_zone_configuration('public', zone_config)
if not is_valid:
    print("❌ Invalid zone configuration")

from django_revolution.utils import validate_environment

validation_result = validate_environment()
if validation_result['success']:
    print("✅ Environment is valid")
else:
    print(f"❌ Environment issues: {validation_result['errors']}")

from django_revolution.openapi.generator import GenerationResult

result = GenerationResult(
    success=True,
    schemas={'public': Path('openapi/schemas/public.yaml')},
    typescript_client=Path('clients/typescript/index.ts'),
    python_client=Path('clients/python/client.py'),
    archive=Path('openapi/archive/2024-01-15_10-30-00.zip'),
    errors=[],
    warnings=[]
)

from django_revolution.zones import ZoneInfo

zone_info = ZoneInfo(
    name='public',
    apps=['accounts', 'billing'],
    url_patterns=5,
    schema_patterns=3,
    is_valid=True,
    errors=[],
    warnings=[]
)

from django_revolution.utils import ErrorHandler

error_handler = ErrorHandler()

# Handle exception
result = error_handler.handle_exception(
    exception,
    context="zone generation"
)

# Validate path
is_valid = error_handler.validate_path(Path("openapi/schemas"))

# Validate file
is_valid = error_handler.validate_file(Path("settings.py"))

from django_revolution.utils import Logger

logger = Logger("my_module")

logger.info("Starting generation...")
logger.success("Generation completed!")
logger.warning("Some warnings occurred")
logger.error("Generation failed")
logger.debug("Debug information")

# settings.py
from django_revolution.app_config import ZoneConfig, get_revolution_config

zones = {
    'public': ZoneConfig(
        apps=['accounts', 'billing'],
        title='Public API',
        description='Public endpoints',
        public=True,
        auth_required=False,
        version='v1'
    )
}

DJANGO_REVOLUTION = get_revolution_config(
    project_root=BASE_DIR,
    zones=zones,
    debug=DEBUG
)

# settings.py
from django_revolution.app_config import ZoneConfig, MonorepoConfig, get_revolution_config

zones = {
    'public': ZoneConfig(
        apps=['accounts', 'billing', 'payments'],
        title='Public API',
        description='Public endpoints',
        public=True,
        auth_required=False,
        version='v1'
    ),
    'admin': ZoneConfig(
        apps=['admin_panel', 'analytics'],
        title='Admin API',
        description='Administrative endpoints',
        public=False,
        auth_required=True,
        version='v1'
    )
}

monorepo = MonorepoConfig(
    enabled=True,
    path=str(BASE_DIR.parent.parent / 'monorepo'),
    api_package_path='packages/api/src'
)

DJANGO_REVOLUTION = get_revolution_config(
    project_root=BASE_DIR,
    zones=zones,
    monorepo=monorepo,
    debug=DEBUG
)