Main Generation API

def generate(
    input_: Path | str | ParseResult | Mapping[str, Any],
    *,
    input_filename: str | None = None,
    input_file_type: InputFileType = InputFileType.Auto,
    output: Path | None = None,
    output_model_type: DataModelType = DataModelType.PydanticBaseModel,
    target_python_version: PythonVersion = PythonVersionMin,
    base_class: str = "",
    additional_imports: list[str] | None = None,
    custom_template_dir: Path | None = None,
    extra_template_data: defaultdict[str, dict[str, Any]] | None = None,
    validation: bool = False,
    field_constraints: bool = False,
    snake_case_field: bool = False,
    strip_default_none: bool = False,
    aliases: Mapping[str, str] | None = None,
    disable_timestamp: bool = False,
    enable_version_header: bool = False,
    allow_population_by_field_name: bool = False,
    allow_extra_fields: bool = False,
    extra_fields: str | None = None,
    apply_default_values_for_required_fields: bool = False,
    force_optional_for_required_fields: bool = False,
    class_name: str | None = None,
    use_standard_collections: bool = False,
    use_schema_description: bool = False,
    use_field_description: bool = False,
    use_default_kwarg: bool = False,
    reuse_model: bool = False,
    encoding: str = "utf-8",
    enum_field_as_literal: LiteralType | None = None,
    use_one_literal_as_default: bool = False,
    set_default_enum_member: bool = False,
    use_subclass_enum: bool = False,
    strict_nullable: bool = False,
    use_generic_container_types: bool = False,
    enable_faux_immutability: bool = False,
    disable_appending_item_suffix: bool = False,
    strict_types: Sequence[StrictTypes] | None = None,
    empty_enum_field_name: str | None = None,
    custom_class_name_generator: Callable[[str], str] | None = None,
    field_extra_keys: set[str] | None = None,
    field_include_all_keys: bool = False,
    field_extra_keys_without_x_prefix: set[str] | None = None,
    openapi_scopes: list[OpenAPIScope] | None = None,
    include_path_parameters: bool = False,
    graphql_scopes: list[GraphQLScope] | None = None,
    wrap_string_literal: bool | None = None,
    use_title_as_name: bool = False,
    use_operation_id_as_name: bool = False,
    use_unique_items_as_set: bool = False,
    http_headers: Sequence[tuple[str, str]] | None = None,
    http_ignore_tls: bool = False,
    use_annotated: bool = False,
    use_non_positive_negative_number_constrained_types: bool = False,
    original_field_name_delimiter: str | None = None,
    use_double_quotes: bool = False,
    use_union_operator: bool = False,
    collapse_root_models: bool = False,
    special_field_name_prefix: str | None = None,
    remove_special_field_name_prefix: bool = False,
    capitalise_enum_members: bool = False,
    keep_model_order: bool = False,
    custom_file_header: str | None = None,
    custom_file_header_path: Path | None = None,
    custom_formatters: list[str] | None = None,
    custom_formatters_kwargs: dict[str, Any] | None = None,
    use_pendulum: bool = False,
    http_query_parameters: Sequence[tuple[str, str]] | None = None,
    treat_dot_as_module: bool = False,
    use_exact_imports: bool = False,
    union_mode: UnionMode | None = None,
    output_datetime_class: DatetimeClassType | None = None,
    keyword_only: bool = False,
    frozen_dataclasses: bool = False,
    no_alias: bool = False,
    formatters: list[Formatter] = DEFAULT_FORMATTERS,
    parent_scoped_naming: bool = False,
) -> None:
    """
    Generate Python data models from input schema.
    
    Args:
        input_: Input source - can be:
            - Path: Local file path to schema
            - str: Raw schema content as string
            - ParseResult: URL to remote schema
            - Mapping: Dictionary containing schema data
        input_filename: Name for input file (used in generated comments)
        input_file_type: Format of input data (auto-detected if Auto)
        output: Output file path (None writes to stdout)
        output_model_type: Python model type to generate
        target_python_version: Target Python version for generated code
        base_class: Custom base class for generated models
        additional_imports: Extra imports to include in generated code
        custom_template_dir: Directory containing custom Jinja2 templates
        extra_template_data: Additional data for custom templates
        validation: Enable Pydantic validation features
        field_constraints: Include field validation constraints
        snake_case_field: Convert field names to snake_case
        strip_default_none: Remove None default values from fields
        aliases: Custom field name aliases mapping
        disable_timestamp: Skip timestamp in generated file header
        enable_version_header: Include package version in file header
        allow_population_by_field_name: Allow population by original field names
        allow_extra_fields: Allow extra fields in models
        extra_fields: How to handle extra fields ('allow', 'forbid', 'ignore')
        apply_default_values_for_required_fields: Set defaults for required fields
        force_optional_for_required_fields: Make all fields optional
        class_name: Root class name for single-class generation
        use_standard_collections: Use built-in collections instead of typing
        use_schema_description: Use schema descriptions in docstrings
        use_field_description: Use field descriptions in field definitions
        use_default_kwarg: Use default= kwarg in field definitions
        reuse_model: Reuse models with same structure
        encoding: File encoding for input/output
        enum_field_as_literal: Convert enums to Literal types
        use_one_literal_as_default: Use single literal as default value
        set_default_enum_member: Set first enum member as default
        use_subclass_enum: Generate enum subclasses
        strict_nullable: Strict nullable field handling
        use_generic_container_types: Use generic types for containers
        enable_faux_immutability: Enable immutable-like behavior
        disable_appending_item_suffix: Don't append 'Item' suffix to names
        strict_types: Enable strict typing for specified types
        empty_enum_field_name: Name for empty enum fields
        custom_class_name_generator: Function to generate class names
        field_extra_keys: Extra keys to preserve in field metadata
        field_include_all_keys: Include all keys in field metadata
        field_extra_keys_without_x_prefix: Extra keys without x- prefix
        openapi_scopes: Scopes to parse from OpenAPI spec
        include_path_parameters: Include path parameters in models
        graphql_scopes: Scopes to parse from GraphQL schema
        wrap_string_literal: Wrap string literals in quotes
        use_title_as_name: Use title field as model name
        use_operation_id_as_name: Use operationId as model name
        use_unique_items_as_set: Convert uniqueItems arrays to sets
        http_headers: Headers for HTTP requests to remote schemas
        http_ignore_tls: Ignore TLS verification for HTTPS requests
        use_annotated: Use typing.Annotated for field annotations
        use_non_positive_negative_number_constrained_types: Use constrained numeric types
        original_field_name_delimiter: Delimiter for original field names
        use_double_quotes: Use double quotes in generated code
        use_union_operator: Use | union operator syntax (Python 3.10+)
        collapse_root_models: Merge root models into single class
        special_field_name_prefix: Prefix for special field names
        remove_special_field_name_prefix: Remove special prefixes from field names
        capitalise_enum_members: Capitalize enum member names
        keep_model_order: Preserve model definition order
        custom_file_header: Custom header for generated files
        custom_file_header_path: Path to file containing custom header
        custom_formatters: List of custom formatter class names
        custom_formatters_kwargs: Arguments for custom formatters
        use_pendulum: Use pendulum for datetime types
        http_query_parameters: Query parameters for HTTP requests
        treat_dot_as_module: Treat dots in names as module separators
        use_exact_imports: Use exact imports instead of wildcards
        union_mode: Union mode for Pydantic v2 (left_to_right, smart)
        output_datetime_class: Datetime class type for output
        keyword_only: Generate keyword-only fields
        frozen_dataclasses: Generate frozen dataclasses
        no_alias: Don't generate field aliases
        formatters: Code formatters to apply (Black, isort, Ruff)
        parent_scoped_naming: Use parent scope in model names
        
    Raises:
        Error: Base exception for generation errors
        InvalidClassNameError: When generated class names are invalid
        FileNotFoundError: When input file is not found
    """

from datamodel_code_generator import generate, DataModelType
from pathlib import Path

generate(
    input_=Path("schema.json"),
    output=Path("models.py"),
    output_model_type=DataModelType.PydanticV2BaseModel
)

from urllib.parse import urlparse
from datamodel_code_generator import generate

generate(
    input_=urlparse("https://example.com/api/schema.yaml"),
    output=Path("api_models.py"),
    http_headers=[("Authorization", "Bearer token")]
)

from datamodel_code_generator import generate, InputFileType
from pathlib import Path

schema_json = '''
{
  "type": "object",
  "properties": {
    "name": {"type": "string"},
    "age": {"type": "integer", "minimum": 0}
  },
  "required": ["name"]
}
'''

generate(
    input_=schema_json,
    input_file_type=InputFileType.JsonSchema,
    output=Path("person.py"),
    field_constraints=True
)

from datamodel_code_generator import generate, DataModelType
from pathlib import Path

generate(
    input_=Path("openapi.yaml"),
    output=Path("dataclasses_models.py"),
    output_model_type=DataModelType.DataclassesDataclass,
    frozen_dataclasses=True,
    use_schema_description=True,
    snake_case_field=True
)

from datamodel_code_generator.format import Formatter

generate(
    input_=Path("schema.yaml"),
    output=Path("formatted_models.py"),
    formatters=[Formatter.BLACK, Formatter.ISORT, Formatter.RUFF_FORMAT],
    use_double_quotes=True,
    target_python_version=PythonVersion.PY_311
)

generate(
    input_=schema_path,
    output=output_path,
    output_model_type=DataModelType.PydanticV2BaseModel,
    target_python_version=PythonVersion.PY_311,
    use_union_operator=True,
    use_annotated=True,
    union_mode="smart"
)

generate(
    input_=schema_path,
    output=output_path,
    output_model_type=DataModelType.TypingTypedDict,
    use_standard_collections=True,
    enum_field_as_literal=LiteralType.All
)

generate(
    input_=openapi_path,
    output=output_path,
    input_file_type=InputFileType.OpenAPI,
    openapi_scopes=[OpenAPIScope.Schemas, OpenAPIScope.Paths],
    include_path_parameters=True,
    use_operation_id_as_name=True
)