Skip to Content
FeaturesModulesCode GenerationConfiguration

Configuration

Complete reference for django_generator configuration models.

Config

Main configuration container:

from django_cfg.modules.django_generator import Config, OpenAPI, Centrifugo, ORM
 
config = Config(
    openapi=OpenAPI(...),       # OpenAPI client generation
    centrifugo=Centrifugo(...), # Centrifugo RPC clients
    orm=ORM(...),               # FastAPI/SQLModel generation
)

OpenAPI

OpenAPI client generation configuration:

from django_cfg.modules.django_generator import OpenAPI, Target, ExtensionTarget
 
OpenAPI(
    targets=[...],              # List of Target objects
    extensions=ExtensionTarget(...),  # Auto-discover extensions
    go_module="github.com/org/repo",  # Go module path
)

Parameters

ParameterTypeDescription
targetslist[Target]Generation targets
extensionsExtensionTarget | NoneExtension auto-discovery config
go_modulestr | NoneGo module path for generated code

Target

Single generation target:

from django_cfg.modules.django_generator import Target, Language, TargetType
 
Target(
    lang=Language.TYPESCRIPT,
    type=TargetType.ADMIN,
    path=Path("frontend/api/generated"),
    groups=["cfg_*", "profiles"],
    post_build="pnpm build",
)

Parameters

ParameterTypeDefaultDescription
langLanguageRequiredTarget platform
typeTargetType | strRequiredTarget type identifier
pathPathRequiredOutput directory
groupslist[str]RequiredAPI groups to include
post_buildstr | NoneNoneCommand to run after generation

ExtensionTarget

Auto-discover extension packages:

from django_cfg.modules.django_generator import ExtensionTarget, Language
 
ExtensionTarget(
    lang=Language.TYPESCRIPT,
    frontend_path=Path("frontend/extensions"),
    package_pattern="ext-{name}",
    output_pattern="src/api/generated",
    group_prefix="ext_",
    post_build=None,
)

Parameters

ParameterTypeDefaultDescription
langLanguageTYPESCRIPTTarget platform
frontend_pathPathRequiredDirectory to scan for extensions
package_patternstr"ext-{name}"Package naming pattern
output_patternstr"src/api/generated"Output path within package
group_prefixstr"ext_"Prefix for Django API groups
post_buildstr | NoneNonePost-generation command

Discovery Logic

frontend/extensions/
├── ext-support/          # Matches pattern "ext-{name}"
│   └── src/api/generated/  # Has generated/ folder = has API
├── ext-leads/
│   └── src/api/generated/
├── ext-base/             # No generated/ folder = skipped
│   └── src/components/

Results in:

  • ext-support → group ext_support → Target for ext_support
  • ext-leads → group ext_leads → Target for ext_leads
  • ext-base → skipped (no API)

Language (Platform)

Available platforms:

from django_cfg.modules.django_generator import Language, Platform
 
# Language and Platform are aliases
Language.TYPESCRIPT  # TypeScript/JavaScript
Language.PYTHON      # Python with httpx
Language.GO          # Go
Language.SWIFT       # Swift (OpenAPI Runtime)
Language.SWIFT_CODABLE  # Swift Codable (simple)
Language.PROTO       # Protocol Buffers

Platform Methods

# Get platforms for API generation
Platform.api_platforms()
# {TYPESCRIPT, PYTHON, GO, SWIFT, SWIFT_CODABLE, PROTO}
 
# Default platforms
Platform.default_platforms()
# {TYPESCRIPT, PYTHON, GO}
 
# Check if external generator
Platform.SWIFT.is_external  # True (uses apple/swift-openapi-generator)

TargetType

Predefined target types:

from django_cfg.modules.django_generator import TargetType
 
TargetType.ADMIN       # Admin panel
TargetType.WEB         # Public web app
TargetType.PACKAGES    # Shared packages
TargetType.EXTENSIONS  # Extension modules
TargetType.PARSERS     # Parsers/scrapers
TargetType.SDK         # SDK distribution

Custom types are also supported:

Target(
    type="mobile",  # Custom string type
    ...
)

ORM Configuration

Generate FastAPI/SQLModel from Django models:

from django_cfg.modules.django_generator import ORM, ORMTarget, ORMGenerator
 
ORM(
    targets=[
        ORMTarget(
            output=Path("fastapi/src/orm"),
            generator=ORMGenerator.FASTAPI,
            apps=["profiles", "catalog"],
        ),
    ],
    include_crud=True,
    include_schemas=True,
    include_relationships=False,
    include_database_config=True,
    async_mode=True,
    exclude_apps=["admin", "auth", "sessions"],
    use_jsonb=True,
    use_array_fields=True,
    database_env_var="DATABASE_URL",
)

ORM Parameters

ParameterTypeDefaultDescription
targetslist[ORMTarget][]Generation targets
include_crudboolTrueGenerate CRUD repositories
include_schemasboolTrueGenerate Pydantic schemas
include_relationshipsboolFalseGenerate SQLModel relationships
include_database_configboolTrueGenerate database.py
async_modeboolTrueGenerate async code
exclude_appslist[str]Django default appsApps to skip
use_jsonbboolTrueUse JSONB for JSONField
use_array_fieldsboolTrueUse native ARRAY type

GeneratorOptions

Typed options for programmatic generation:

from django_cfg.modules.django_generator import GeneratorOptions, Platform
 
options = GeneratorOptions(
    platforms={Platform.TYPESCRIPT, Platform.PYTHON},
    groups=["profiles", "catalog"],
    dry_run=False,
    verbose=True,
    streamlit=False,
    external_go=False,
    external_python=False,
)

Parameters

ParameterTypeDefaultDescription
platformsset[Platform]TS, PY, GOPlatforms to generate
groupslist[str] | NoneNoneGroups to filter (None = all)
dry_runboolFalseShow what would be generated
verboseboolFalseVerbose output
streamlitboolFalseCopy to Streamlit app
external_goboolFalseUse oapi-codegen
external_pythonboolFalseUse openapi-python-client

Complete Example

# generation.py
from pathlib import Path
 
from django_cfg.modules.django_generator import (
    Config,
    OpenAPI,
    Centrifugo,
    ORM,
    Target,
    ExtensionTarget,
    ORMTarget,
    Language,
    TargetType,
    ORMGenerator,
)
 
ROOT = Path(__file__).parent
FRONTEND = ROOT.parent / "frontend"
FASTAPI = ROOT.parent / "fastapi_server"
 
config = Config(
    # OpenAPI clients
    openapi=OpenAPI(
        targets=[
            # Admin panel
            Target(
                lang=Language.TYPESCRIPT,
                type=TargetType.ADMIN,
                path=FRONTEND / "apps/admin/api/generated",
                groups=["cfg_*", "profiles"],
            ),
            # Public web
            Target(
                lang=Language.TYPESCRIPT,
                type=TargetType.WEB,
                path=FRONTEND / "apps/web/api/generated",
                groups=["catalog", "products"],
            ),
            # Python SDK
            Target(
                lang=Language.PYTHON,
                type=TargetType.SDK,
                path=ROOT / "sdk/generated",
                groups=["*"],  # All groups
            ),
        ],
        # Auto-discover extensions
        extensions=ExtensionTarget(
            frontend_path=FRONTEND / "extensions",
            package_pattern="ext-{name}",
            output_pattern="src/api/generated",
            group_prefix="ext_",
        ),
        go_module="github.com/myorg/myproject",
    ),
 
    # Centrifugo RPC
    centrifugo=Centrifugo(
        targets=[
            Target(
                lang=Language.TYPESCRIPT,
                type=TargetType.WEB,
                path=FRONTEND / "packages/ws/generated",
                groups=["notifications"],
            ),
        ],
    ),
 
    # FastAPI ORM
    orm=ORM(
        targets=[
            ORMTarget(
                output=FASTAPI / "src/orm",
                generator=ORMGenerator.FASTAPI,
                apps=["profiles", "catalog"],
            ),
        ],
        include_crud=True,
        async_mode=True,
    ),
)
Last updated on
DRF ThemeCLI Commands

Django-CFG documentation — a modern, type-safe Django framework with Pydantic v2 configuration.

Documentation

Frontend

Resources

Company

© 2026 Django-CFG. MIT Licensed.GitHub ↗