JSON a Python - Generar Dataclasses y Modelos Pydantic en Línea
Convierte JSON a dataclasses de Python, Pydantic BaseModel o TypedDict con inferencia de tipos, conversión snake_case y detección de fechas — 100% en tu navegador.
Preguntas Frecuentes
¿Qué es un convertidor de JSON a Python?
Un convertidor de JSON a Python es una herramienta que genera automáticamente definiciones de clases Python a partir de datos JSON. En lugar de escribir manualmente dataclasses o modelos Pydantic con nombres de campos y anotaciones de tipo, pegas un objeto JSON de ejemplo y la herramienta infiere los tipos Python correctos para cada campo. Soporta múltiples formatos de salida: dataclasses de Python (biblioteca estándar), Pydantic BaseModel (con validación integrada) y TypedDict (hints de tipo ligeros).
¿Cómo genero clases Python desde JSON?
Pega tus datos JSON en el campo de entrada del lado izquierdo. La herramienta genera instantáneamente código Python en el panel de salida de la derecha. Elige tu formato de salida preferido (dataclass, Pydantic BaseModel o TypedDict) usando el selector de formato. Puedes personalizar la salida configurando el nombre de la clase raíz, habilitando la conversión snake_case, marcando valores null como Optional y activando la detección de fecha/hora.
¿Debo usar dataclass o Pydantic BaseModel?
Usa dataclasses de Python cuando necesites un contenedor de datos simple y sin dependencias con anotaciones de tipo. Las dataclasses son parte de la biblioteca estándar (Python 3.7+) y no tienen sobrecarga de validación en tiempo de ejecución. Usa Pydantic BaseModel cuando necesites validación de datos en tiempo de ejecución, coerción automática de tipos, serialización/deserialización JSON y soporte de alias. Usa TypedDict cuando solo necesites hints de tipo para datos tipo diccionario sin sobrecarga en tiempo de ejecución.
¿Esta herramienta soporta Pydantic v2?
Sí, esta herramienta genera código Pydantic v2 exclusivamente. Usa la sintaxis moderna de Pydantic v2 incluyendo model_config = ConfigDict(...) en lugar del patrón legacy class Config. Cuando la conversión snake_case está habilitada, genera Field(alias='originalKey') con model_config = ConfigDict(populate_by_name=True).
¿Están seguros mis datos JSON al usar esta herramienta?
Sí, completamente. Esta herramienta procesa todo en tu navegador usando JavaScript del lado del cliente. Tus datos JSON nunca salen de tu computadora — no hay cargas al servidor, no hay llamadas API y no hay almacenamiento de datos. Esto la hace segura para usar con respuestas API sensibles, esquemas de datos propietarios y archivos de configuración confidenciales.
¿Cómo maneja la herramienta los campos null y opcionales?
Cuando un campo JSON tiene un valor null, la herramienta lo marca como Optional con un valor predeterminado de None. Para la sintaxis moderna de Python (3.10+), esto se convierte en 'field_name: str | None = None'. Para la sintaxis legacy, usa 'field_name: Optional[str] = None'. También puedes habilitar el toggle 'Todo opcional' para marcar todos los campos como opcionales.
¿Cómo se manejan los objetos JSON anidados?
Cada objeto JSON anidado se convierte en una clase nombrada separada. Por ejemplo, si tu JSON tiene un objeto 'user' con un sub-objeto 'address', la herramienta crea tanto una clase 'User' como una clase 'Address', con 'User' referenciando 'Address' como tipo de campo. Las clases se ordenan correctamente en la salida para que las dependencias aparezcan antes de las clases que las referencian.
Ejemplos de Código
// JSON to Python dataclass/Pydantic generator
function jsonToPython(json, rootName = 'Root', format = 'dataclass') {
const classes = [];
function toPascalCase(str) {
return str.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : '')
.replace(/^./, s => s.toUpperCase());
}
function toSnakeCase(str) {
return str.replace(/([A-Z])/g, '_$1').replace(/^_/, '').toLowerCase();
}
function inferType(value, name) {
if (value === null) return 'None';
if (typeof value === 'boolean') return 'bool';
if (typeof value === 'number') {
return Number.isInteger(value) ? 'int' : 'float';
}
if (typeof value === 'string') return 'str';
if (Array.isArray(value)) {
if (value.length === 0) return 'list[Any]';
return `list[${inferType(value[0], name)}]`;
}
if (typeof value === 'object') {
const className = toPascalCase(name);
const fields = Object.entries(value).map(([key, val]) => {
const pyType = inferType(val, key);
const fieldName = toSnakeCase(key);
if (format === 'pydantic' && fieldName !== key) {
return ` ${fieldName}: ${pyType} = Field(alias="${key}")`;
}
return ` ${fieldName}: ${pyType}`;
});
if (format === 'dataclass') {
classes.push(`@dataclass\nclass ${className}:\n${fields.join('\n')}`);
} else if (format === 'pydantic') {
classes.push(`class ${className}(BaseModel):\n${fields.join('\n')}`);
} else {
classes.push(`class ${className}(TypedDict):\n${fields.join('\n')}`);
}
return className;
}
return 'Any';
}
const parsed = JSON.parse(json);
inferType(parsed, rootName);
return classes.reverse().join('\n\n');
}
// Example
const json = '{"userName": "alice", "age": 30, "address": {"city": "NYC"}}';
console.log(jsonToPython(json, 'User', 'pydantic'));
// Output:
// class Address(BaseModel):
// city: str
//
// class User(BaseModel):
// user_name: str = Field(alias="userName")
// age: int
// address: Address