tessl/pypi-datamodel-code-generator
Generates Python data models from various schema formats including OpenAPI, JSON Schema, GraphQL, and raw data
—
Pending
types-config.mddocs/
Data Types and Configuration
Core enums, constants, and configuration types that control the behavior of datamodel-code-generator. These types define supported input formats, output model types, and various generation options.
Capabilities
Input Format Types
Enum defining all supported input schema formats with automatic detection capability.
class InputFileType(Enum):
"""Supported input schema formats for code generation."""
Auto = "auto" # Automatic format detection
OpenAPI = "openapi" # OpenAPI 3.x specification
JsonSchema = "jsonschema" # JSON Schema (Draft 4, 6, 7, 2019-09, 2020-12)
Json = "json" # Raw JSON data (converted to JSON Schema)
Yaml = "yaml" # Raw YAML data (converted to JSON Schema)
Dict = "dict" # Python dictionary (converted to JSON Schema)
CSV = "csv" # CSV data (inferred schema from headers/first row)
GraphQL = "graphql" # GraphQL schema definitionOutput Model Types
Enum defining all supported Python model types for code generation output.
class DataModelType(Enum):
"""Supported Python model types for generated output."""
PydanticBaseModel = "pydantic.BaseModel" # Pydantic v1 BaseModel
PydanticV2BaseModel = "pydantic_v2.BaseModel" # Pydantic v2 BaseModel
DataclassesDataclass = "dataclasses.dataclass" # Python dataclasses
TypingTypedDict = "typing.TypedDict" # TypedDict for type hints
MsgspecStruct = "msgspec.Struct" # msgspec Struct (high-performance)OpenAPI Parsing Scopes
Configuration for which parts of an OpenAPI specification to process during code generation.
class OpenAPIScope(Enum):
"""OpenAPI specification sections to include in parsing."""
Schemas = "schemas" # Component schemas (data models)
Paths = "paths" # API endpoint definitions
Tags = "tags" # API operation groupings
Parameters = "parameters" # Reusable parameter definitionsGraphQL Parsing Scopes
Configuration for GraphQL schema parsing scope.
class GraphQLScope(Enum):
"""GraphQL schema sections to include in parsing."""
Schema = "schema" # Full GraphQL schema definitionPython Version Targeting
Enum for specifying target Python version compatibility in generated code.
class PythonVersion(Enum):
"""Python version targets for generated code compatibility."""
PY_39 = "3.9"
PY_310 = "3.10"
PY_311 = "3.11"
PY_312 = "3.12"
PY_313 = "3.13"
# Constants
PythonVersionMin: PythonVersion = PythonVersion.PY_39 # Minimum supported versionCode Formatter Types
Enum defining available code formatters for post-processing generated code.
class Formatter(Enum):
"""Available code formatters for generated Python code."""
BLACK = "black" # Black code formatter
ISORT = "isort" # Import statement sorter
RUFF_CHECK = "ruff-check" # Ruff linter (check mode)
RUFF_FORMAT = "ruff-format" # Ruff formatter
# Default formatter configuration
DEFAULT_FORMATTERS: list[Formatter] = [Formatter.BLACK, Formatter.ISORT]Datetime Class Options
Enum for specifying datetime class types in generated models.
class DatetimeClassType(Enum):
"""Datetime class types for temporal field generation."""
Datetime = "datetime" # Standard datetime.datetime
Awaredatetime = "awaredatetime" # Timezone-aware datetime
Naivedatetime = "naivedatetime" # Timezone-naive datetimeLiteral Type Configuration
Enum controlling how enum fields are converted to literal types.
class LiteralType(Enum):
"""Literal type conversion options for enum fields."""
All = "all" # Convert all enum fields to literals
One = "one" # Convert single-value enums to literalsStrict Type Configuration
Enum for enabling strict typing validation on specific Python types.
class StrictTypes(Enum):
"""Python types that can have strict validation enabled."""
str = "str" # Strict string validation
bytes = "bytes" # Strict bytes validation
int = "int" # Strict integer validation
float = "float" # Strict float validation
bool = "bool" # Strict boolean validationUnion Mode Configuration (Pydantic v2)
Enum for configuring union type handling in Pydantic v2 models.
class UnionMode(Enum):
"""Union discrimination modes for Pydantic v2."""
left_to_right = "left_to_right" # Try union members left to right
smart = "smart" # Smart union discriminationVersion Constants
Constants defining supported Python version range.
MIN_VERSION: Final[int] = 9 # Minimum Python version (3.9)
MAX_VERSION: Final[int] = 13 # Maximum Python version (3.13)Default Configuration Values
Common default values used throughout the generation process.
DEFAULT_BASE_CLASS: str = "pydantic.BaseModel" # Default base class
DEFAULT_ENCODING: str = "utf-8" # Default file encoding
DEFAULT_MAX_VARIABLE_LENGTH: int = 100 # Debug variable display limit
# Format module constants
DEFAULT_FORMATTERS: list[Formatter] = [Formatter.BLACK, Formatter.ISORT]
PythonVersionMin: PythonVersion = PythonVersion.PY_39 # Minimum supported versionUsage Examples
Input Type Detection and Configuration
from datamodel_code_generator import InputFileType, generate
# Explicit input type specification
generate(
input_=schema_content,
input_file_type=InputFileType.JsonSchema, # Explicit JSON Schema
output=output_path
)
# Automatic detection (default)
generate(
input_=schema_file,
input_file_type=InputFileType.Auto, # Auto-detect from content
output=output_path
)Output Model Type Selection
from datamodel_code_generator import DataModelType
# Generate different model types
model_types = [
DataModelType.PydanticV2BaseModel, # Modern Pydantic v2
DataModelType.DataclassesDataclass, # Standard library dataclasses
DataModelType.TypingTypedDict, # Type hints only
DataModelType.MsgspecStruct, # High-performance msgspec
]
for model_type in model_types:
generate(
input_=schema_path,
output=Path(f"models_{model_type.value.replace('.', '_')}.py"),
output_model_type=model_type
)Python Version Targeting
from datamodel_code_generator import PythonVersion
# Target modern Python features
generate(
input_=schema_path,
output=output_path,
target_python_version=PythonVersion.PY_311,
use_union_operator=True, # Use | instead of Union
use_standard_collections=True # Use list instead of List
)OpenAPI Scope Configuration
from datamodel_code_generator import OpenAPIScope
# Generate only data models (no path/operation models)
generate(
input_=openapi_spec,
output=output_path,
input_file_type=InputFileType.OpenAPI,
openapi_scopes=[OpenAPIScope.Schemas] # Only component schemas
)
# Generate comprehensive API models
generate(
input_=openapi_spec,
output=output_path,
input_file_type=InputFileType.OpenAPI,
openapi_scopes=[
OpenAPIScope.Schemas,
OpenAPIScope.Paths,
OpenAPIScope.Parameters
]
)Code Formatter Configuration
from datamodel_code_generator.format import Formatter
# Custom formatter chain
generate(
input_=schema_path,
output=output_path,
formatters=[
Formatter.BLACK, # Format code style
Formatter.ISORT, # Sort imports
Formatter.RUFF_FORMAT # Additional Ruff formatting
]
)
# No formatting (raw output)
generate(
input_=schema_path,
output=output_path,
formatters=[] # Skip all formatters
)Strict Typing Configuration
from datamodel_code_generator.types import StrictTypes
# Enable strict validation for specific types
generate(
input_=schema_path,
output=output_path,
strict_types=[
StrictTypes.str, # Strict string validation
StrictTypes.int, # Strict integer validation
StrictTypes.bool # Strict boolean validation
]
)Literal Type Configuration
from datamodel_code_generator.parser import LiteralType
# Convert all enums to literals (useful for TypedDict)
generate(
input_=schema_path,
output=output_path,
output_model_type=DataModelType.TypingTypedDict,
enum_field_as_literal=LiteralType.All
)Pydantic v2 Union Mode
from datamodel_code_generator.model.pydantic_v2 import UnionMode
# Configure smart union discrimination
generate(
input_=schema_path,
output=output_path,
output_model_type=DataModelType.PydanticV2BaseModel,
union_mode=UnionMode.smart # Smart union handling
)Install with Tessl CLI
npx tessl i tessl/pypi-datamodel-code-generator