zod-to-x 2.1.0-dev.2 → 2.2.0

package/README.md

@@ -3,7 +3,10 @@
   <em style="font-size: smaller;">Image generated using Canvas AI.</em>
 </p>
 <p align="center">
-  <a href="https://github.com/rroumenov/zod-to-x/releases" target="_blank">
+  <a href="https://www.npmjs.com/package/zod-to-x" target="_blank">
+    <img src="https://img.shields.io/badge/npm%20-red?style=for-the-badge&logo=npm" alt="npm">
+  </a>
+  <a href="https://github.com/rroumenov/zod-to-x/releases" target="_blank" style="margin-left: 10px;">
     <img src="https://img.shields.io/badge/View%20Changelog-brightgreen?style=for-the-badge" alt="View Changelog">
   </a>
   <a href="https://playcode.io/2277071" target="_blank" style="margin-left: 10px;">
@@ -20,6 +23,14 @@
 
 <span style="color: red;">**Important Announcement:**</span> `zod-to-x@2.0.0` has been released, introducing migration to Zod V4. At this stage, only the existent behavior has been migrated, while new features like Literal Templates are still under analysis. Only the complete Zod V4 version will be supported, **not v4-mini**. Additionally, `zod-to-x@1.X.Y` will continue to be maintained for Zod V3, and any new transpilation languages will also be supported in version 1.
 
+<p align="center">
+  <strong>Supported Languages:</strong><br><br>
+  <img src="https://img.shields.io/badge/TypeScript-3178C6?style=for-the-badge&logo=typescript&logoColor=white" alt="TypeScript">
+  <img src="https://img.shields.io/badge/Python-3776AB?style=for-the-badge&logo=python&logoColor=white" alt="Python">
+  <img src="https://img.shields.io/badge/C++-00599C?style=for-the-badge&logo=cplusplus&logoColor=white" alt="C++">
+  <img src="https://img.shields.io/badge/Protobuf-4285F4?style=for-the-badge&logo=google&logoColor=white" alt="Protobuf">
+</p>
+
 
 
 ## Table of contents
@@ -32,10 +43,11 @@
 - [Layered modeling](#layered-modeling)
   - [Usage example](#usage-example)
   - [Custom layers](#custom-layers)
-  - [Generic types](#generic-types) <sup>*(new)*</sup>
+  - [Generic types](#generic-types)
 - [Currently supported output languages](#currently-supported-output-languages)
   - [Typescript](#1-typescript)
-  - [C++](#2-c)
+  - [Python](#2-python) <sup>*(new)*</sup>
+  - [C++](#3-c)
 - [Additional utils](#additional-utils)
   - [Protobuf V3 generation](#2-zod2protov3)
 - [Mapping of supported Zod Types by Language](#mapping-of-supported-zod-types-by-langauge)
@@ -50,7 +62,7 @@ Managing data consistency across multiple layers and languages is a common chall
 Define your data structures in one place using the powerful [`@zod`](https://github.com/colinhacks/zod) library. This eliminates redundancy, reduces inconsistencies, and simplifies maintenance across your entire codebase, all while allowing you to continue leveraging any npm package in the [`@zod`](https://github.com/colinhacks/zod) ecosystem.
 
 2. **Multi-Language Compatibility**  
-Generate data models for TypeScript, Protobuf V3 and C++ (with languages like Golang on the roadmap). No more manually rewriting models for different platforms.
+Generate data models for TypeScript, Python (Pydantic), C++, and Protobuf V3 (with languages like Golang on the roadmap). No more manually rewriting models for different platforms.
 
 3. **Enhanced Productivity**  
 Automate the transpilation of data models to save time, reduce errors, and let your team focus on business logic instead of boilerplate code.
@@ -600,7 +612,13 @@ Common options:
   - **keepKeys**: Specifies whether property names should follow the TypeScript naming convention (false) or remain as originally defined (true). The default is `false`.
 - [Examples](https://github.com/rroumenov/zod-to-x/blob/main/test/test_zod2ts)
 
-### 2) C++
+### 2) Python
+`Pydantic` is used for data validation and serialization/deserialization. Generates Pydantic BaseModel classes with full type hints.
+- Options:
+  - **keepKeys**: Specifies whether property names should follow the Python naming convention (false) or remain as originally defined (true). The default is `false`.
+- [Examples](https://github.com/rroumenov/zod-to-x/blob/main/test/test_zod2py)
+
+### 3) C++
 `Nlohmann` dependency is used for data serialization/deserialization. For *C++11*, `Boost` dependency is used. For *C++17* or newer, standard libraries are used.
 - Options:
   - **includeNulls**: When serializing, include all values even if `null`. Defaults to `false`.

package/dist/core/ast_node.d.ts

@@ -64,11 +64,13 @@ export declare class Zod2Ast {
      */
     private _getEnumValues;
     /**
-     * Intersects the properties of two AST nodes and returns the combined properties.
+     * Intersects the properties of two Zod object schemas and returns the combined properties.
+     * Processes the Zod shapes directly instead of looking up cached AST nodes, ensuring that
+     * instantiated generic types (from useGenericType) are correctly resolved.
      *
-     * @param left - The left AST definition to intersect.
-     * @param right - The right AST definition to intersect.
-     * @returns An object containing the combined properties of the left and right AST nodes.
+     * @param left - The left Zod object schema.
+     * @param right - The right Zod object schema.
+     * @returns An object containing the combined properties of the left and right schemas.
      */
     private _intersectAstNodes;
     /**

package/dist/core/ast_node.js

@@ -138,18 +138,30 @@ class Zod2Ast {
         });
     }
     /**
-     * Intersects the properties of two AST nodes and returns the combined properties.
+     * Intersects the properties of two Zod object schemas and returns the combined properties.
+     * Processes the Zod shapes directly instead of looking up cached AST nodes, ensuring that
+     * instantiated generic types (from useGenericType) are correctly resolved.
      *
-     * @param left - The left AST definition to intersect.
-     * @param right - The right AST definition to intersect.
-     * @returns An object containing the combined properties of the left and right AST nodes.
+     * @param left - The left Zod object schema.
+     * @param right - The right Zod object schema.
+     * @returns An object containing the combined properties of the left and right schemas.
      */
     _intersectAstNodes(left, right) {
-        const leftData = this.nodes.get(left.name);
-        const rightData = this.nodes.get(right.name);
-        return {
-            properties: Object.assign(Object.assign({}, leftData.properties), rightData.properties),
-        };
+        const properties = {};
+        for (const schema of [left, right]) {
+            const shape = schema.def.shape;
+            for (const key in shape) {
+                if (zod_helpers_1.ZodHelpers.isZodPromise(shape[key]) &&
+                    zod_helpers_1.ZodHelpers.isZod2XGeneric(shape[key])) {
+                    const templateKey = shape[key].unwrap().def.values[0];
+                    properties[key] = new core_1.ASTGenericType(templateKey);
+                }
+                else {
+                    properties[key] = this._zodToAST(shape[key]);
+                }
+            }
+        }
+        return { properties };
     }
     /**
      * Merges multiple AST definitions into a single AST object containing combined properties.
@@ -425,7 +437,7 @@ class Zod2Ast {
             }
         }
         else {
-            const intersectedProperties = this._intersectAstNodes(item.left, item.right);
+            const intersectedProperties = this._intersectAstNodes(def.left, def.right);
             item.newObject = new core_1.ASTObject({
                 name,
                 properties: intersectedProperties.properties,

package/dist/layered-modeling/model.d.ts

@@ -43,5 +43,6 @@ export declare class Zod2XModel {
     transpile(target: Target<"Zod2Cpp">, opt?: TargetOpt<"Zod2Cpp">, astOpt?: AstOpt): string;
     transpile(target: Target<"Zod2Cpp17">, opt?: TargetOpt<"Zod2Cpp17">, astOpt?: AstOpt): string;
     transpile(target: Target<"Zod2Ts">, opt?: TargetOpt<"Zod2Ts">, astOpt?: AstOpt): string;
+    transpile(target: Target<"Zod2Py">, opt?: TargetOpt<"Zod2Py">, astOpt?: AstOpt): string;
 }
 export {};

package/dist/transpilers/index.d.ts

@@ -1,2 +1,3 @@
 export { Zod2Ts } from "./typescript/runner";
 export { Zod2Cpp, Zod2Cpp17 } from "./cpp/runner";
+export { Zod2Py } from "./python/runner";

package/dist/transpilers/index.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Zod2Cpp17 = exports.Zod2Cpp = exports.Zod2Ts = void 0;
+exports.Zod2Py = exports.Zod2Cpp17 = exports.Zod2Cpp = exports.Zod2Ts = void 0;
 var runner_1 = require("./typescript/runner");
 Object.defineProperty(exports, "Zod2Ts", { enumerable: true, get: function () { return runner_1.Zod2Ts; } });
 var runner_2 = require("./cpp/runner");
 Object.defineProperty(exports, "Zod2Cpp", { enumerable: true, get: function () { return runner_2.Zod2Cpp; } });
 Object.defineProperty(exports, "Zod2Cpp17", { enumerable: true, get: function () { return runner_2.Zod2Cpp17; } });
+var runner_3 = require("./python/runner");
+Object.defineProperty(exports, "Zod2Py", { enumerable: true, get: function () { return runner_3.Zod2Py; } });

package/dist/transpilers/python/libs.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @description Python library imports for Pydantic
+ * @returns
+ */
+export declare function getLibs(): {
+    baseModel: string;
+    fieldImport: string;
+    aliasGenerator: string;
+    annotatedType: string;
+    typeAliasType: string;
+    genericType: string;
+    typeVarType: string;
+    enumType: string;
+    anyType: string;
+    listType: string;
+    dictType: string;
+    setType: string;
+    tupleType: string;
+    unionType: string;
+    optionalType: string;
+    literalType: string;
+    datetimeType: string;
+};

package/dist/transpilers/python/libs.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLibs = getLibs;
+/**
+ * @description Python library imports for Pydantic
+ * @returns
+ */
+function getLibs() {
+    return {
+        baseModel: "from pydantic import BaseModel, ConfigDict",
+        fieldImport: "from pydantic import Field",
+        aliasGenerator: "from pydantic.alias_generators import to_camel",
+        annotatedType: "from typing import Annotated",
+        typeAliasType: "from typing import TypeAlias",
+        genericType: "from typing import Generic",
+        typeVarType: "from typing import TypeVar",
+        enumType: "from enum import Enum",
+        anyType: "from typing import Any",
+        listType: "from typing import List",
+        dictType: "from typing import Dict",
+        setType: "from typing import Set",
+        tupleType: "from typing import Tuple",
+        unionType: "from typing import Union",
+        optionalType: "from typing import Optional",
+        literalType: "from typing import Literal",
+        datetimeType: "from datetime import datetime",
+    };
+}

package/dist/transpilers/python/options.d.ts

@@ -0,0 +1,9 @@
+import { IZodToXOpt } from "../../core";
+export interface IZod2PyOpt extends Omit<IZodToXOpt, "indent"> {
+    /**
+     * By default (false), structure/class property names are converted according to the target
+     * language's naming conventions. If set to true, the original property names are preserved.
+     */
+    keepKeys?: boolean;
+}
+export declare const defaultOpts: IZod2PyOpt;

package/dist/transpilers/python/options.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOpts = void 0;
+exports.defaultOpts = {
+    includeComments: true,
+    useImports: true,
+    keepKeys: false,
+};

package/dist/transpilers/python/runner.d.ts

@@ -0,0 +1,116 @@
+import { ASTAliasedTypes, ASTEnum, ASTIntersection, ASTNode, ASTObject, ASTUnion, Zod2X } from "../../core";
+import { IZod2PyOpt } from "./options";
+export declare class Zod2Py extends Zod2X<IZod2PyOpt> {
+    protected readonly commentKey = "#";
+    protected lib: {
+        baseModel: string;
+        fieldImport: string;
+        aliasGenerator: string;
+        annotatedType: string;
+        typeAliasType: string;
+        genericType: string;
+        typeVarType: string;
+        enumType: string;
+        anyType: string;
+        listType: string;
+        dictType: string;
+        setType: string;
+        tupleType: string;
+        unionType: string;
+        optionalType: string;
+        literalType: string;
+        datetimeType: string;
+    };
+    private baseSchemaAdded;
+    private typeVars;
+    constructor(opt?: IZod2PyOpt);
+    protected runAfter(): void;
+    protected runBefore(): void;
+    /**
+     * Adds BaseSchema class definition if not already added.
+     * This is the base class for all Pydantic models with shared configuration.
+     */
+    private _addBaseSchema;
+    /**
+     * Declares TypeVars that haven't been declared yet.
+     * Adds them right before their first usage.
+     * Ex: T = TypeVar('T')
+     */
+    private _declareNewTypeVars;
+    /**
+     * Consolidates multiline imports from the same module and sorts them alphabetically.
+     * Modifies this.imports Set to contain consolidated import statements.
+     */
+    private _consolidateImports;
+    protected addImportFromFile(filename: string, namespace: string): string;
+    protected getTypeFromExternalNamespace(namespace: string, typeName: string): string;
+    protected addExtendedType(name: string, parentNamespace: string, aliasOf: string, opt?: {
+        type?: "union" | "d-union" | "alias";
+        isInternal?: boolean;
+        templates?: string;
+        isClass?: boolean;
+    }): void;
+    protected getGenericTemplatesTranslation(data: ASTNode): string | undefined;
+    protected checkExtendedTypeInclusion(data: ASTNode, type?: "alias" | "union" | "d-union"): boolean;
+    protected getAnyType: () => string;
+    protected getBooleanType: () => string;
+    protected getDateType: () => string;
+    /** Ex: Set[TypeA] */
+    protected getSetType: (itemType: string) => string;
+    protected getStringType: () => string;
+    /** Ex: Tuple[TypeA, TypeB] */
+    protected getTupleType: (itemsType: string[]) => string;
+    /** Ex: Union[TypeA, TypeB] */
+    protected getUnionType: (itemsType: string[]) => string;
+    /** Ex: TypeA & TypeB -> intersection handling */
+    protected getIntersectionType: (itemsType: string[]) => string;
+    /** Ex: int or float depending on isInt flag */
+    protected getNumberType: (isInt: boolean, range: {
+        min?: number;
+        max?: number;
+    }) => string;
+    /** Ex: List[List[TypeA]] */
+    protected getArrayType(arrayType: string, arrayDeep: number): string;
+    /** Ex: Literal["value"] or Literal[true] or EnumName.ENUM_VALUE */
+    protected getLiteralStringType(value: string | number | boolean, parentEnumNameKey?: [string, string]): string | number;
+    /** Ex: Dict[TypeA, TypeB] */
+    protected getMapType(keyType: string, valueType: string): string;
+    /** Ex: Dict[TypeA, TypeB] */
+    protected getRecordType(keyType: string, valueType: string): string;
+    protected transpileAliasedType(data: ASTAliasedTypes): void;
+    /** Ex:
+     *  class MyEnum(str, Enum):
+     *      ITEM_KEY1 = "ItemValue1"
+     *      ITEM_KEY2 = "ItemValue2"
+     *
+     *  # Or for mixed types:
+     *  class MyEnum(Enum):
+     *      ITEM_KEY1 = 1
+     *      ITEM_KEY2 = "ItemValue2"
+     */
+    protected transpileEnum(data: ASTEnum): void;
+    protected transpileIntersection(data: ASTIntersection): void;
+    protected transpileStruct(data: ASTObject): void;
+    protected transpileUnion(data: ASTUnion): void;
+    /**
+     * Creates a wrapper class for a union type.
+     * Python/Pydantic needs this for proper serialization/deserialization of unions.
+     * Ex:
+     *   class UnionItemWrapper(BaseSchema):
+     *       data: UnionItem
+     */
+    private _createUnionWrapper;
+    /** Ex:
+     *  class MyStruct(BaseSchema):
+     *      att1: TypeA
+     *      att2: Optional[TypeB] = None
+     *
+     *  # Or with generics:
+     *  class MyGenericStruct(BaseSchema, Generic[T]):
+     *      data: T
+     * */
+    private _transpileStructAsClass;
+    /** For Class attributes.
+     *  Ex: attribute1: Optional[TypeA] = None */
+    private _transpileMember;
+}

package/dist/transpilers/python/runner.js

@@ -0,0 +1,397 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Zod2Py = void 0;
+const case_1 = __importDefault(require("case"));
+const core_1 = require("../../core");
+const options_1 = require("./options");
+const libs_1 = require("./libs");
+class Zod2Py extends core_1.Zod2X {
+    constructor(opt = {}) {
+        super(Object.assign(Object.assign({}, options_1.defaultOpts), opt));
+        this.commentKey = "#";
+        this.baseSchemaAdded = false;
+        this.typeVars = new Set();
+        this.getAnyType = () => {
+            this.imports.add(this.lib.anyType);
+            return "Any";
+        };
+        this.getBooleanType = () => "bool";
+        this.getDateType = () => {
+            this.imports.add(this.lib.datetimeType);
+            return "datetime";
+        };
+        /** Ex: Set[TypeA] */
+        this.getSetType = (itemType) => {
+            this.imports.add(this.lib.setType);
+            return `Set[${itemType}]`;
+        };
+        this.getStringType = () => "str";
+        /** Ex: Tuple[TypeA, TypeB] */
+        this.getTupleType = (itemsType) => {
+            this.imports.add(this.lib.tupleType);
+            return `Tuple[${itemsType.join(", ")}]`;
+        };
+        /** Ex: Union[TypeA, TypeB] */
+        this.getUnionType = (itemsType) => {
+            this.imports.add(this.lib.unionType);
+            return `Union[${itemsType.join(", ")}]`;
+        };
+        /** Ex: TypeA & TypeB -> intersection handling */
+        this.getIntersectionType = (itemsType) => {
+            // Python doesn't have intersection types, we'll create a new class
+            return itemsType.join(" & "); // This will be handled in transpileIntersection
+        };
+        /** Ex: int or float depending on isInt flag */
+        this.getNumberType = (isInt, range) => {
+            return isInt ? "int" : "float";
+        };
+        this.lib = (0, libs_1.getLibs)();
+    }
+    runAfter() {
+        this._consolidateImports();
+    }
+    runBefore() { }
+    /**
+     * Adds BaseSchema class definition if not already added.
+     * This is the base class for all Pydantic models with shared configuration.
+     */
+    _addBaseSchema() {
+        if (this.baseSchemaAdded)
+            return;
+        this.baseSchemaAdded = true;
+        this.imports.add(this.lib.baseModel);
+        if (this.opt.keepKeys !== true) {
+            this.imports.add(this.lib.aliasGenerator);
+        }
+        this.push0("class BaseSchema(BaseModel):");
+        this.push1("model_config = ConfigDict(");
+        if (this.opt.keepKeys !== true) {
+            this.push2("alias_generator=to_camel,");
+            this.push2("serialize_by_alias=True,");
+            this.push2("populate_by_name=True,");
+        }
+        this.push2("use_enum_values=True");
+        this.push1(")");
+        this.push0("");
+    }
+    /**
+     * Declares TypeVars that haven't been declared yet.
+     * Adds them right before their first usage.
+     * Ex: T = TypeVar('T')
+     */
+    _declareNewTypeVars(templates) {
+        const newTypeVars = Array.from(templates).filter((t) => !this.typeVars.has(t));
+        if (newTypeVars.length === 0)
+            return;
+        this.imports.add(this.lib.typeVarType);
+        newTypeVars.forEach((typeVar) => {
+            this.push0(`${typeVar} = TypeVar('${typeVar}')`);
+            this.typeVars.add(typeVar);
+        });
+        this.push0("");
+    }
+    /**
+     * Consolidates multiline imports from the same module and sorts them alphabetically.
+     * Modifies this.imports Set to contain consolidated import statements.
+     */
+    _consolidateImports() {
+        const importGroups = new Map();
+        const simpleImports = new Set();
+        // Group imports by module
+        this.imports.forEach((importStatement) => {
+            if (importStatement.startsWith("from ") && importStatement.includes(" import ")) {
+                // Parse "from module import item" format
+                const match = importStatement.match(/^from\s+(\S+)\s+import\s+(.+)$/);
+                if (match) {
+                    const module = match[1];
+                    const items = match[2].split(",").map((item) => item.trim());
+                    if (!importGroups.has(module)) {
+                        importGroups.set(module, new Set());
+                    }
+                    items.forEach((item) => {
+                        if (item) {
+                            importGroups.get(module).add(item);
+                        }
+                    });
+                }
+            }
+            else if (importStatement.startsWith("import ")) {
+                // Simple import statement
+                simpleImports.add(importStatement);
+            }
+        });
+        // Clear existing imports
+        this.imports.clear();
+        // Add consolidated "from" imports back to this.imports (sorted by module)
+        const sortedModules = Array.from(importGroups.keys()).sort();
+        sortedModules.forEach((module) => {
+            const items = Array.from(importGroups.get(module)).sort();
+            if (items.length === 1) {
+                this.imports.add(`from ${module} import ${items[0]}`);
+            }
+            else {
+                this.imports.add(`from ${module} import ${items.join(", ")}`);
+            }
+        });
+        // Add simple imports back to this.imports (sorted)
+        const sortedSimpleImports = Array.from(simpleImports).sort();
+        sortedSimpleImports.forEach((imp) => {
+            this.imports.add(imp);
+        });
+    }
+    addImportFromFile(filename, namespace) {
+        const moduleName = filename.endsWith(".py") ? filename.slice(0, -3) : filename;
+        return `import ${moduleName} as ${namespace}`;
+    }
+    getTypeFromExternalNamespace(namespace, typeName) {
+        return `${namespace}.${typeName}`;
+    }
+    addExtendedType(name, parentNamespace, aliasOf, opt) {
+        var _a;
+        const extendedType = (opt === null || opt === void 0 ? void 0 : opt.isInternal)
+            ? aliasOf
+            : this.getTypeFromExternalNamespace(parentNamespace, aliasOf);
+        const templates = (_a = opt === null || opt === void 0 ? void 0 : opt.templates) !== null && _a !== void 0 ? _a : "";
+        if (opt === null || opt === void 0 ? void 0 : opt.isClass) {
+            // For classes (ASTObject, ASTIntersection), use inheritance with templates
+            this.push0(`class ${name}(${extendedType}${templates}): ...\n`);
+        }
+        else {
+            // For type aliases (primitives, unions, etc.), use TypeAlias
+            this.imports.add(this.lib.typeAliasType);
+            this.push0(`${name}: TypeAlias = ${extendedType}${templates}\n`);
+        }
+    }
+    getGenericTemplatesTranslation(data) {
+        if ((data instanceof core_1.ASTObject || data instanceof core_1.ASTDefinition) &&
+            data.templatesTranslation.length > 0) {
+            return ("[" +
+                data.templatesTranslation
+                    .map((t) => {
+                    if (this.isExternalTypeImport(t)) {
+                        this.addExternalTypeImport(t);
+                        return this.getTypeFromExternalNamespace(t.parentNamespace, t.aliasOf);
+                    }
+                    else {
+                        return t.aliasOf;
+                    }
+                })
+                    .join(", ") +
+                "]");
+        }
+    }
+    checkExtendedTypeInclusion(data, type) {
+        // Determine if the aliased type is a class (ASTObject or ASTIntersection with newObject)
+        const isClass = data instanceof core_1.ASTObject ||
+            (data instanceof core_1.ASTIntersection && data.newObject !== undefined);
+        if (this.isExternalTypeImport(data)) {
+            if (data.aliasOf) {
+                this.addExtendedType(data.name, data.parentNamespace, data.aliasOf, {
+                    type,
+                    templates: this.getGenericTemplatesTranslation(data),
+                    isClass,
+                });
+                this.addExternalTypeImport(data);
+            }
+            return true;
+        }
+        else if (data.aliasOf) {
+            this.addExtendedType(data.name, data.parentNamespace, data.aliasOf, {
+                type,
+                isInternal: true,
+                templates: this.getGenericTemplatesTranslation(data),
+                isClass,
+            });
+            return true;
+        }
+        return false;
+    }
+    /** Ex: List[List[TypeA]] */
+    getArrayType(arrayType, arrayDeep) {
+        this.imports.add(this.lib.listType);
+        let output = `List[${arrayType}]`;
+        for (let i = 0; i < arrayDeep - 1; i++) {
+            output = `List[${output}]`;
+        }
+        return output;
+    }
+    /** Ex: Literal["value"] or Literal[true] or EnumName.ENUM_VALUE */
+    getLiteralStringType(value, parentEnumNameKey) {
+        if (!parentEnumNameKey)
+            this.imports.add(this.lib.literalType);
+        return ("Literal[" +
+            (parentEnumNameKey
+                ? `${parentEnumNameKey[0]}.${case_1.default.constant(case_1.default.snake(parentEnumNameKey[1]))}`
+                : typeof value === "boolean"
+                    ? case_1.default.capital(value.toString())
+                    : `${isNaN(Number(value)) ? `"${value}"` : value}`) +
+            "]");
+    }
+    /** Ex: Dict[TypeA, TypeB] */
+    getMapType(keyType, valueType) {
+        this.imports.add(this.lib.dictType);
+        return `Dict[${keyType}, ${valueType}]`;
+    }
+    /** Ex: Dict[TypeA, TypeB] */
+    getRecordType(keyType, valueType) {
+        this.imports.add(this.lib.dictType);
+        return `Dict[${keyType}, ${valueType}]`;
+    }
+    transpileAliasedType(data) {
+        if (this.checkExtendedTypeInclusion(data, "alias")) {
+            return;
+        }
+        let extendedType = undefined;
+        this.addComment(data.description);
+        if (data instanceof core_1.ASTArray) {
+            extendedType = this.getAttributeType(data.item);
+        }
+        else {
+            extendedType = this.getAttributeType(data);
+        }
+        if (extendedType !== undefined) {
+            this.imports.add(this.lib.typeAliasType);
+            this.push0(`${data.name}: TypeAlias = ${extendedType}\n`);
+        }
+    }
+    /** Ex:
+     *  class MyEnum(str, Enum):
+     *      ITEM_KEY1 = "ItemValue1"
+     *      ITEM_KEY2 = "ItemValue2"
+     *
+     *  # Or for mixed types:
+     *  class MyEnum(Enum):
+     *      ITEM_KEY1 = 1
+     *      ITEM_KEY2 = "ItemValue2"
+     */
+    transpileEnum(data) {
+        if (this.checkExtendedTypeInclusion(data, "alias")) {
+            return;
+        }
+        this.imports.add(this.lib.enumType);
+        this.addComment(data.description);
+        // Check if all values are strings
+        const allStrings = data.values.every(([, value]) => typeof value === "string");
+        const enumParent = allStrings ? "(str, Enum)" : "(Enum)";
+        this.push0(`class ${data.name}${enumParent}:`);
+        data.values.forEach(([key, value]) => {
+            const keyName = case_1.default.constant(case_1.default.snake(key));
+            const enumValue = typeof value === "string" ? `"${value}"` : `${value}`;
+            this.push1(`${keyName} = ${enumValue}`);
+        });
+        this.push0("");
+    }
+    transpileIntersection(data) {
+        if (this.checkExtendedTypeInclusion(data)) {
+            return;
+        }
+        this._addBaseSchema();
+        this.addComment(data.description);
+        // Use multiple inheritance like C++ for intersections
+        const leftType = this.getAttributeType(data.left);
+        const rightType = this.getAttributeType(data.right);
+        this.push0(`class ${data.name}(${leftType}, ${rightType}): ...\n`);
+    }
+    transpileStruct(data) {
+        if (this.checkExtendedTypeInclusion(data)) {
+            return;
+        }
+        this._addBaseSchema();
+        if (data.templates.size > 0) {
+            this._declareNewTypeVars(data.templates);
+        }
+        this.addComment(data.description);
+        this._transpileStructAsClass(data);
+    }
+    transpileUnion(data) {
+        if (this.checkExtendedTypeInclusion(data, data.discriminantKey === undefined ? "union" : "d-union")) {
+            return;
+        }
+        // Python uses Union type aliases (like C++), not merged classes
+        this._addBaseSchema();
+        this.addComment(data.description);
+        const attributesTypes = data.options.map(this.getAttributeType.bind(this));
+        // For discriminated unions, use Annotated with Field discriminator
+        if (data.discriminantKey) {
+            this.imports.add(this.lib.annotatedType);
+            this.imports.add(this.lib.fieldImport);
+            this.push0(`${data.name} = Annotated[`);
+            this.push1(`${this.getUnionType(attributesTypes)},`);
+            this.push1(`Field(discriminator='${data.discriminantKey}')`);
+            this.push0(`]\n`);
+        }
+        else {
+            this.push0(`${data.name} = ${this.getUnionType(attributesTypes)}\n`);
+        }
+        this._createUnionWrapper(data.name);
+    }
+    /**
+     * Creates a wrapper class for a union type.
+     * Python/Pydantic needs this for proper serialization/deserialization of unions.
+     * Ex:
+     *   class UnionItemWrapper(BaseSchema):
+     *       data: UnionItem
+     */
+    _createUnionWrapper(unionName) {
+        const wrapperName = `${unionName}Wrapper`;
+        this.push0(`class ${wrapperName}(BaseSchema):`);
+        this.push1(`data: ${unionName}`);
+        this.push0("");
+    }
+    /** Ex:
+     *  class MyStruct(BaseSchema):
+     *      att1: TypeA
+     *      att2: Optional[TypeB] = None
+     *
+     *  # Or with generics:
+     *  class MyGenericStruct(BaseSchema, Generic[T]):
+     *      data: T
+     * */
+    _transpileStructAsClass(data) {
+        // Handle generic templates
+        let baseClasses = "BaseSchema";
+        if (data.templates.size > 0) {
+            const templates = Array.from(data.templates);
+            this.imports.add(this.lib.genericType);
+            baseClasses += `, Generic[${templates.join(", ")}]`;
+        }
+        this.push0(`class ${data.name}(${baseClasses}):`);
+        const hasProperties = Object.keys(data.properties).length > 0;
+        if (!hasProperties) {
+            this.push1("pass");
+            this.push0("");
+            return;
+        }
+        // Generate fields
+        for (const [key, value] of Object.entries(data.properties)) {
+            const keyName = this.opt.keepKeys === true ? key : case_1.default.snake(key);
+            this._transpileMember(keyName, value);
+        }
+        this.push0("");
+    }
+    /** For Class attributes.
+     *  Ex: attribute1: Optional[TypeA] = None */
+    _transpileMember(memberName, memberNode) {
+        const pythonType = this.getAttributeType(memberNode);
+        const isOptional = memberNode.isOptional || memberNode.isNullable;
+        let typeAnnotation;
+        if (isOptional) {
+            this.imports.add(this.lib.optionalType);
+            typeAnnotation = pythonType.startsWith("Optional[")
+                ? pythonType
+                : `Optional[${pythonType}]`;
+        }
+        else {
+            typeAnnotation = pythonType;
+        }
+        if (memberNode.description && !memberNode.name && !this.isTranspilerable(memberNode)) {
+            this.addComment(memberNode.description, `\n${this.indent[1]}`);
+        }
+        const defaultValue = isOptional ? " = None" : "";
+        this.push1(`${memberName}: ${typeAnnotation}${defaultValue}`);
+    }
+}
+exports.Zod2Py = Zod2Py;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-to-x",
-  "version": "2.1.0-dev.2",
+  "version": "2.2.0",
   "description": "Multi language types generation from Zod schemas.",
   "main": "dist/index.js",
   "files": [
@@ -13,6 +13,8 @@
     "format:check": "prettier --check .",
     "test": "find ./test -name \"err-*\" -delete && vitest --run",
     "test:cpp": "bash ./test/test_zod2cpp/test_cpp.sh",
+    "test:py": "bash ./test/test_zod2py/test_py.sh",
+    "test:all": "npm run test:cpp && npm run test:py",
     "ts-run": "ts-node -r tsconfig-paths/register",
     "prepare": "husky"
   },